From e64f2bbb1746ec83aff65197c22783dc3d00a68b Mon Sep 17 00:00:00 2001 From: Romain Ruetschi Date: Thu, 13 Apr 2023 15:47:20 +0200 Subject: [PATCH 01/15] Add new channel upgrade proto messages --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 685 ++++++++++++++++++++++++++++++- 2 files changed, 685 insertions(+), 2 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 3496d706..c11242a7 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -c0acd5bd1778f2b7ecdf593006f56bd3e273bd49 +9bca644453430b5daab860cc6e3bb1fd3b45245d diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 5b74963e..6249189b 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -164,7 +164,7 @@ pub mod acknowledgement { } } /// State defines if a channel is in one of the following states: -/// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED. +/// CLOSED, INIT, TRYOPEN, OPEN, INITUPGRADE, TRYUPGRADE or UNINITIALIZED. #[derive(::serde::Serialize, ::serde::Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] @@ -181,6 +181,12 @@ 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 started the channel upgrade handshake. + /// The chain that is proposing the upgrade should set the channel state from OPEN to UPGRADEINIT. + Initupgrade = 5, + /// A channel has acknowledged the upgrade handshake step on the counterparty chain. + /// The counterparty chain that accepts the upgrade should set the channel state from OPEN to UPGRADETRY. + Tryupgrade = 6, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -194,6 +200,8 @@ impl State { State::Tryopen => "STATE_TRYOPEN", State::Open => "STATE_OPEN", State::Closed => "STATE_CLOSED", + State::Initupgrade => "STATE_INITUPGRADE", + State::Tryupgrade => "STATE_TRYUPGRADE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -204,6 +212,8 @@ impl State { "STATE_TRYOPEN" => Some(Self::Tryopen), "STATE_OPEN" => Some(Self::Open), "STATE_CLOSED" => Some(Self::Closed), + "STATE_INITUPGRADE" => Some(Self::Initupgrade), + "STATE_TRYUPGRADE" => Some(Self::Tryupgrade), _ => None, } } @@ -279,6 +289,33 @@ pub struct PacketSequence { #[prost(uint64, tag = "3")] pub sequence: u64, } +/// UpgradeTimeout defines a type which encapsulates the upgrade timeout values at which the counterparty +/// must no longer proceed with the upgrade handshake. +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpgradeTimeout { + /// block height after which the upgrade times out + #[prost(message, optional, tag = "1")] + pub timeout_height: ::core::option::Option, + /// block timestamp (in nanoseconds) after which the upgrade times out + #[prost(uint64, tag = "2")] + pub timeout_timestamp: u64, +} +/// 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. +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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 error: ::prost::alloc::string::String, +} /// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It /// is called by a relayer on Chain A. #[derive(::serde::Serialize, ::serde::Deserialize)] @@ -334,6 +371,8 @@ pub struct MsgChannelOpenTry { pub struct MsgChannelOpenTryResponse { #[prost(string, tag = "1")] pub version: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, } /// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge /// the change of channel state to TRYOPEN on Chain B. @@ -521,6 +560,166 @@ pub struct MsgAcknowledgementResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } +/// MsgChanelUpgradeInit defines the request type for the ChannelUpgradeInit rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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 proposed_upgrade_channel: ::core::option::Option, + #[prost(message, optional, tag = "4")] + pub timeout_height: ::core::option::Option, + #[prost(uint64, tag = "5")] + pub timeout_timestamp: u64, + #[prost(string, tag = "6")] + pub signer: ::prost::alloc::string::String, +} +/// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeInitResponse {} +/// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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(message, optional, tag = "3")] + pub counterparty_channel: ::core::option::Option, + #[prost(uint64, tag = "4")] + pub counterparty_sequence: u64, + #[prost(message, optional, tag = "5")] + pub proposed_upgrade_channel: ::core::option::Option, + #[prost(message, optional, tag = "6")] + pub timeout_height: ::core::option::Option, + #[prost(uint64, tag = "7")] + pub timeout_timestamp: u64, + #[prost(bytes = "vec", tag = "8")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "9")] + pub proof_upgrade_timeout: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "10")] + pub proof_upgrade_sequence: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "11")] + pub proof_height: ::core::option::Option, + #[prost(string, tag = "12")] + pub signer: ::prost::alloc::string::String, +} +/// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTryResponse {} +/// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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_channel: ::core::option::Option, + #[prost(bytes = "vec", tag = "4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub proof_upgrade_sequence: ::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, +} +/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAckResponse {} +/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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(message, optional, tag = "3")] + pub counterparty_channel: ::core::option::Option, + #[prost(bytes = "vec", tag = "4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub proof_upgrade_error: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "6")] + pub proof_upgrade_sequence: ::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, +} +/// MsgChannelUpgradeConfirmResponse defines the MsgChannelUpgradeConfirm response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeConfirmResponse {} +/// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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(message, optional, tag = "4")] + pub previous_error_receipt: ::core::option::Option, + #[prost(bytes = "vec", tag = "5")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "6")] + pub proof_error_receipt: ::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, +} +/// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTimeoutResponse {} +/// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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, +} +/// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeCancelResponse {} /// ResponseResultType defines the possible outcomes of the execution of a message #[derive(::serde::Serialize, ::serde::Deserialize)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -907,6 +1106,170 @@ 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 + } + /// 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 + } } } /// Generated server implementations. @@ -998,6 +1361,54 @@ pub mod msg_server { 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, + >; + /// ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. + async fn channel_upgrade_timeout( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. + async fn channel_upgrade_cancel( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Msg defines the ibc/channel Msg service. #[derive(Debug)] @@ -1519,6 +1930,278 @@ pub mod msg_server { }; 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 ChannelUpgradeInitSvc { + type Response = super::MsgChannelUpgradeInitResponse; + 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 { + (*inner).channel_upgrade_init(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeInitSvc(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/ChannelUpgradeTry" => { + #[allow(non_camel_case_types)] + 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, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + (*inner).channel_upgrade_try(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeTrySvc(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/ChannelUpgradeAck" => { + #[allow(non_camel_case_types)] + 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 { + (*inner).channel_upgrade_ack(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = 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 ChannelUpgradeConfirmSvc { + type Response = super::MsgChannelUpgradeConfirmResponse; + 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 { + (*inner).channel_upgrade_confirm(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeConfirmSvc(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/ChannelUpgradeTimeout" => { + #[allow(non_camel_case_types)] + 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, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + (*inner).channel_upgrade_timeout(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeTimeoutSvc(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/ChannelUpgradeCancel" => { + #[allow(non_camel_case_types)] + 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, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + (*inner).channel_upgrade_cancel(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 = ChannelUpgradeCancelSvc(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( From d9450a59e95d8573f936fef6a4e0e201bd6fa40f Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Thu, 20 Apr 2023 10:08:41 +0200 Subject: [PATCH 02/15] Update ibc-go commit to latest of the branch 04-channel-upgrade --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 263 +++++++++++++++++++++++++++++-- 2 files changed, 254 insertions(+), 11 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index c11242a7..1e97589c 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -9bca644453430b5daab860cc6e3bb1fd3b45245d +81a709b49a42504737d25be0e812d830f9a0897c diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 6249189b..0cb82adb 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -22,6 +22,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, } /// IdentifiedChannel defines a channel with additional port and channel /// identifier fields. @@ -289,6 +293,34 @@ pub struct PacketSequence { #[prost(uint64, tag = "3")] pub sequence: u64, } +/// Upgrade is a verifiable type which contains the relevant information +/// for an attempted upgrade. It provides the proposed changes to the channel +/// end, the timeout for this upgrade attempt and the latest packet sequence sent +/// to allow the counterparty to block sends after the upgrade has started. +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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 latest_sequence_send: u64, +} +/// UpgradeFields are the fields in a channel end which may be changed +/// during a channel upgrade. +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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, +} /// UpgradeTimeout defines a type which encapsulates the upgrade timeout values at which the counterparty /// must no longer proceed with the upgrade handshake. #[derive(::serde::Serialize, ::serde::Deserialize)] @@ -297,10 +329,10 @@ pub struct PacketSequence { pub struct UpgradeTimeout { /// block height after which the upgrade times out #[prost(message, optional, tag = "1")] - pub timeout_height: ::core::option::Option, + pub height: ::core::option::Option, /// block timestamp (in nanoseconds) after which the upgrade times out #[prost(uint64, tag = "2")] - pub timeout_timestamp: u64, + pub timestamp: u64, } /// 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 @@ -560,7 +592,7 @@ pub struct MsgAcknowledgementResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } -/// MsgChanelUpgradeInit defines the request type for the ChannelUpgradeInit rpc +/// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -570,19 +602,24 @@ pub struct MsgChannelUpgradeInit { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] - pub proposed_upgrade_channel: ::core::option::Option, + pub fields: ::core::option::Option, #[prost(message, optional, tag = "4")] - pub timeout_height: ::core::option::Option, - #[prost(uint64, tag = "5")] - pub timeout_timestamp: u64, - #[prost(string, tag = "6")] + pub timeout: ::core::option::Option, + #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeInitResponse {} +pub struct MsgChannelUpgradeInitResponse { + #[prost(string, tag = "1")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag = "3")] + pub upgrade_sequence: u64, +} /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] @@ -2647,7 +2684,7 @@ pub struct QueryNextSequenceReceiveRequest { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } -/// QuerySequenceResponse is the request type for the +/// QuerySequenceResponse is the response type for the /// Query/QueryNextSequenceReceiveResponse RPC method #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] @@ -2663,6 +2700,52 @@ pub struct QueryNextSequenceReceiveResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +/// QueryUpgradeSequenceRequest is the request type for the QueryUpgradeSequence RPC method +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeSequenceRequest { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +/// QueryUpgradeSequenceResponse is the response type for the QueryUpgradeSequence RPC method +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeSequenceResponse { + #[prost(uint64, tag = "1")] + pub upgrade_sequence: u64, + #[prost(bytes = "vec", tag = "2")] + pub proof: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "3")] + pub proof_height: ::core::option::Option, +} +/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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, +} +/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[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, +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -3117,6 +3200,58 @@ pub mod query_client { ); self.inner.unary(req, path, codec).await } + /// UpgradeSequence returns the upgrade sequence for a given channel. + pub async fn upgrade_sequence( + &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/UpgradeSequence", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "UpgradeSequence")); + 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 + } } } /// Generated server implementations. @@ -3239,6 +3374,22 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// UpgradeSequence returns the upgrade sequence for a given channel. + async fn upgrade_sequence( + &self, + request: tonic::Request, + ) -> std::result::Result< + 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, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -3929,6 +4080,98 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Query/UpgradeSequence" => { + #[allow(non_camel_case_types)] + struct UpgradeSequenceSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for UpgradeSequenceSvc { + type Response = super::QueryUpgradeSequenceResponse; + 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 { + (*inner).upgrade_sequence(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 = UpgradeSequenceSvc(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/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 { + (*inner).upgrade_error(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) + } _ => { Box::pin(async move { Ok( From 8d85932e92612a4bdc64e7f99d15dae4393aa1eb Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 2 May 2023 10:41:59 +0200 Subject: [PATCH 03/15] Update with TryUpgrade changes --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 141 ++++++++++++++++--------------- 2 files changed, 76 insertions(+), 67 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 1e97589c..abb1b76a 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -81a709b49a42504737d25be0e812d830f9a0897c +1bab3d611f18ba43908c33b56f201fa38f7c16fb diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 0cb82adb..70d5913a 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -629,32 +629,37 @@ pub struct MsgChannelUpgradeTry { 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(uint64, tag = "4")] - pub counterparty_sequence: u64, + #[prost(string, repeated, tag = "3")] + pub proposed_upgrade_connection_hops: ::prost::alloc::vec::Vec< + ::prost::alloc::string::String, + >, + #[prost(message, optional, tag = "4")] + pub upgrade_timeout: ::core::option::Option, #[prost(message, optional, tag = "5")] - pub proposed_upgrade_channel: ::core::option::Option, - #[prost(message, optional, tag = "6")] - pub timeout_height: ::core::option::Option, - #[prost(uint64, tag = "7")] - pub timeout_timestamp: u64, - #[prost(bytes = "vec", tag = "8")] + pub counterparty_proposed_upgrade: ::core::option::Option, + #[prost(uint64, tag = "6")] + pub counterparty_upgrade_sequence: u64, + #[prost(bytes = "vec", tag = "7")] pub proof_channel: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "9")] - pub proof_upgrade_timeout: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "10")] - pub proof_upgrade_sequence: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "11")] + #[prost(bytes = "vec", tag = "8")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "9")] pub proof_height: ::core::option::Option, - #[prost(string, tag = "12")] + #[prost(string, tag = "10")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeTryResponse {} +pub struct MsgChannelUpgradeTryResponse { + #[prost(string, tag = "1")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub version: ::prost::alloc::string::String, + #[prost(enumeration = "ResponseResultType", tag = "3")] + pub result: i32, +} /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] @@ -768,6 +773,8 @@ pub enum ResponseResultType { 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. @@ -779,6 +786,7 @@ impl ResponseResultType { 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. @@ -787,6 +795,7 @@ impl ResponseResultType { "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, } } @@ -2700,45 +2709,47 @@ pub struct QueryNextSequenceReceiveResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } -/// QueryUpgradeSequenceRequest is the request type for the QueryUpgradeSequence RPC method +/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeSequenceRequest { +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, } -/// QueryUpgradeSequenceResponse is the response type for the QueryUpgradeSequence RPC method +/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeSequenceResponse { - #[prost(uint64, tag = "1")] - pub upgrade_sequence: u64, +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, } -/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method +/// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeErrorRequest { +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, } -/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method +/// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeErrorResponse { +pub struct QueryUpgradeResponse { #[prost(message, optional, tag = "1")] - pub error_receipt: ::core::option::Option, + pub upgrade: ::core::option::Option, /// merkle proof of existence #[prost(bytes = "vec", tag = "2")] pub proof: ::prost::alloc::vec::Vec, @@ -3200,12 +3211,12 @@ pub mod query_client { ); self.inner.unary(req, path, codec).await } - /// UpgradeSequence returns the upgrade sequence for a given channel. - pub async fn upgrade_sequence( + /// UpgradeError returns the error receipt if the upgrade handshake failed. + pub async fn upgrade_error( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -3219,19 +3230,19 @@ pub mod query_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/ibc.core.channel.v1.Query/UpgradeSequence", + "/ibc.core.channel.v1.Query/UpgradeError", ); let mut req = request.into_request(); req.extensions_mut() - .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "UpgradeSequence")); + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "UpgradeError")); self.inner.unary(req, path, codec).await } - /// UpgradeError returns the error receipt if the upgrade handshake failed. - pub async fn upgrade_error( + /// Upgrade returns the upgrade for a given port and channel id. + pub async fn upgrade( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -3245,11 +3256,11 @@ pub mod query_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/ibc.core.channel.v1.Query/UpgradeError", + "/ibc.core.channel.v1.Query/Upgrade", ); let mut req = request.into_request(); req.extensions_mut() - .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "UpgradeError")); + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Upgrade")); self.inner.unary(req, path, codec).await } } @@ -3374,14 +3385,6 @@ pub mod query_server { tonic::Response, tonic::Status, >; - /// UpgradeSequence returns the upgrade sequence for a given channel. - async fn upgrade_sequence( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; /// UpgradeError returns the error receipt if the upgrade handshake failed. async fn upgrade_error( &self, @@ -3390,6 +3393,14 @@ pub mod query_server { 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, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -4080,25 +4091,25 @@ pub mod query_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Query/UpgradeSequence" => { + "/ibc.core.channel.v1.Query/UpgradeError" => { #[allow(non_camel_case_types)] - struct UpgradeSequenceSvc(pub Arc); + struct UpgradeErrorSvc(pub Arc); impl< T: Query, - > tonic::server::UnaryService - for UpgradeSequenceSvc { - type Response = super::QueryUpgradeSequenceResponse; + > tonic::server::UnaryService + for UpgradeErrorSvc { + type Response = super::QueryUpgradeErrorResponse; 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 { - (*inner).upgrade_sequence(request).await + (*inner).upgrade_error(request).await }; Box::pin(fut) } @@ -4110,7 +4121,7 @@ pub mod query_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = UpgradeSequenceSvc(inner); + let method = UpgradeErrorSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -4126,26 +4137,24 @@ pub mod query_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Query/UpgradeError" => { + "/ibc.core.channel.v1.Query/Upgrade" => { #[allow(non_camel_case_types)] - struct UpgradeErrorSvc(pub Arc); + struct UpgradeSvc(pub Arc); impl< T: Query, - > tonic::server::UnaryService - for UpgradeErrorSvc { - type Response = super::QueryUpgradeErrorResponse; + > tonic::server::UnaryService + for UpgradeSvc { + type Response = super::QueryUpgradeResponse; 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 { - (*inner).upgrade_error(request).await - }; + let fut = async move { (*inner).upgrade(request).await }; Box::pin(fut) } } @@ -4156,7 +4165,7 @@ pub mod query_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = UpgradeErrorSvc(inner); + let method = UpgradeSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( From 0c5afca553da95ca1f1c56595cfbb6af86b4b95f Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 20 Jun 2023 15:02:13 +0200 Subject: [PATCH 04/15] Update channel upgradability proto definition to latest commit --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 167 ++++++++++++++++++++----------- 2 files changed, 109 insertions(+), 60 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index abb1b76a..bfbc0831 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -1bab3d611f18ba43908c33b56f201fa38f7c16fb +6453bd4af5ec3fc28811fc91d4ad09e871ebd4ef diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 70d5913a..083dced7 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -26,6 +26,9 @@ pub struct Channel { /// the value of 0 indicates the channel has never been upgraded #[prost(uint64, tag = "6")] pub upgrade_sequence: u64, + /// flush status indicates the current status of inflight packet flushing on the channel end + #[prost(enumeration = "FlushStatus", tag = "7")] + pub flush_status: i32, } /// IdentifiedChannel defines a channel with additional port and channel /// identifier fields. @@ -167,6 +170,20 @@ pub mod acknowledgement { Error(::prost::alloc::string::String), } } +/// Timeout defines an execution deadline structure for 04-channel handlers. +/// This includes packet lifecycle handlers as well as the upgrade handshake handlers. +/// A valid Timeout contains either one or both of a timestamp and block height (sequence). +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Timeout { + /// block height after which the packet or upgrade times out + #[prost(message, optional, tag = "1")] + pub height: ::core::option::Option, + /// block timestamp (in nanoseconds) after which the packet or upgrade times out + #[prost(uint64, tag = "2")] + pub timestamp: u64, +} /// State defines if a channel is in one of the following states: /// CLOSED, INIT, TRYOPEN, OPEN, INITUPGRADE, TRYUPGRADE or UNINITIALIZED. #[derive(::serde::Serialize, ::serde::Deserialize)] @@ -191,6 +208,9 @@ pub enum State { /// A channel has acknowledged the upgrade handshake step on the counterparty chain. /// The counterparty chain that accepts the upgrade should set the channel state from OPEN to UPGRADETRY. Tryupgrade = 6, + /// A channel has verified the counterparty chain is in UPGRADETRY. + /// However, there are still in-flight packets on both ends waiting to be flushed before it can move to OPEN. + Ackupgrade = 7, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -206,6 +226,7 @@ impl State { State::Closed => "STATE_CLOSED", State::Initupgrade => "STATE_INITUPGRADE", State::Tryupgrade => "STATE_TRYUPGRADE", + State::Ackupgrade => "STATE_ACKUPGRADE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -218,6 +239,41 @@ impl State { "STATE_CLOSED" => Some(Self::Closed), "STATE_INITUPGRADE" => Some(Self::Initupgrade), "STATE_TRYUPGRADE" => Some(Self::Tryupgrade), + "STATE_ACKUPGRADE" => Some(Self::Ackupgrade), + _ => None, + } + } +} +/// FlushStatus defines the status of a channel end pertaining to in-flight packets during an upgrade handshake. +#[derive(::serde::Serialize, ::serde::Deserialize)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum FlushStatus { + /// Default status, the channel is not in an upgrade handshake + NotinflushUnspecified = 0, + /// The channel end is flushing in-flight packets + Flushing = 1, + /// There are no in-flight packets left and the channel end is ready to move to OPEN + Flushcomplete = 2, +} +impl FlushStatus { + /// 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 { + FlushStatus::NotinflushUnspecified => "FLUSH_STATUS_NOTINFLUSH_UNSPECIFIED", + FlushStatus::Flushing => "FLUSH_STATUS_FLUSHING", + FlushStatus::Flushcomplete => "FLUSH_STATUS_FLUSHCOMPLETE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FLUSH_STATUS_NOTINFLUSH_UNSPECIFIED" => Some(Self::NotinflushUnspecified), + "FLUSH_STATUS_FLUSHING" => Some(Self::Flushing), + "FLUSH_STATUS_FLUSHCOMPLETE" => Some(Self::Flushcomplete), _ => None, } } @@ -304,7 +360,7 @@ pub struct Upgrade { #[prost(message, optional, tag = "1")] pub fields: ::core::option::Option, #[prost(message, optional, tag = "2")] - pub timeout: ::core::option::Option, + pub timeout: ::core::option::Option, #[prost(uint64, tag = "3")] pub latest_sequence_send: u64, } @@ -321,19 +377,6 @@ pub struct UpgradeFields { #[prost(string, tag = "3")] pub version: ::prost::alloc::string::String, } -/// UpgradeTimeout defines a type which encapsulates the upgrade timeout values at which the counterparty -/// must no longer proceed with the upgrade handshake. -#[derive(::serde::Serialize, ::serde::Deserialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct UpgradeTimeout { - /// block height after which the upgrade times out - #[prost(message, optional, tag = "1")] - pub height: ::core::option::Option, - /// block timestamp (in nanoseconds) after which the upgrade times out - #[prost(uint64, tag = "2")] - pub timestamp: u64, -} /// 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. @@ -346,7 +389,7 @@ pub struct ErrorReceipt { pub sequence: u64, /// the error message detailing the cause of failure #[prost(string, tag = "2")] - pub error: ::prost::alloc::string::String, + pub message: ::prost::alloc::string::String, } /// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It /// is called by a relayer on Chain A. @@ -604,7 +647,7 @@ pub struct MsgChannelUpgradeInit { #[prost(message, optional, tag = "3")] pub fields: ::core::option::Option, #[prost(message, optional, tag = "4")] - pub timeout: ::core::option::Option, + pub timeout: ::core::option::Option, #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, } @@ -634,7 +677,7 @@ pub struct MsgChannelUpgradeTry { ::prost::alloc::string::String, >, #[prost(message, optional, tag = "4")] - pub upgrade_timeout: ::core::option::Option, + pub upgrade_timeout: ::core::option::Option, #[prost(message, optional, tag = "5")] pub counterparty_proposed_upgrade: ::core::option::Option, #[prost(uint64, tag = "6")] @@ -655,9 +698,11 @@ pub struct MsgChannelUpgradeTry { pub struct MsgChannelUpgradeTryResponse { #[prost(string, tag = "1")] pub channel_id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub version: ::prost::alloc::string::String, - #[prost(enumeration = "ResponseResultType", tag = "3")] + #[prost(message, optional, tag = "2")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag = "3")] + pub upgrade_sequence: u64, + #[prost(enumeration = "ResponseResultType", tag = "4")] pub result: i32, } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc @@ -669,49 +714,50 @@ pub struct MsgChannelUpgradeAck { 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(enumeration = "FlushStatus", tag = "3")] + pub counterparty_flush_status: i32, + #[prost(message, optional, tag = "4")] + pub counterparty_upgrade: ::core::option::Option, #[prost(bytes = "vec", tag = "5")] - pub proof_upgrade_sequence: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "6")] + 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 = "7")] + #[prost(string, tag = "8")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeAckResponse {} -/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc +pub struct MsgChannelUpgradeAckResponse { + #[prost(enumeration = "ResponseResultType", tag = "1")] + pub result: i32, +} +/// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeConfirm { +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(message, optional, tag = "3")] - pub counterparty_channel: ::core::option::Option, + #[prost(enumeration = "State", tag = "3")] + pub counterparty_channel_state: i32, #[prost(bytes = "vec", tag = "4")] pub proof_channel: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "5")] - pub proof_upgrade_error: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "6")] - pub proof_upgrade_sequence: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "7")] + #[prost(message, optional, tag = "5")] pub proof_height: ::core::option::Option, - #[prost(string, tag = "8")] + #[prost(string, tag = "6")] pub signer: ::prost::alloc::string::String, } -/// MsgChannelUpgradeConfirmResponse defines the MsgChannelUpgradeConfirm response type +/// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeConfirmResponse {} +pub struct MsgChannelUpgradeOpenResponse {} /// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] @@ -738,7 +784,10 @@ pub struct MsgChannelUpgradeTimeout { #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeTimeoutResponse {} +pub struct MsgChannelUpgradeTimeoutResponse { + #[prost(enumeration = "ResponseResultType", tag = "1")] + pub result: i32, +} /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc #[derive(::serde::Serialize, ::serde::Deserialize)] #[allow(clippy::derive_partial_eq_without_eq)] @@ -1232,12 +1281,12 @@ pub mod msg_client { .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( + /// ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. + pub async fn channel_upgrade_open( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner @@ -1251,12 +1300,12 @@ pub mod msg_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/ibc.core.channel.v1.Msg/ChannelUpgradeConfirm", + "/ibc.core.channel.v1.Msg/ChannelUpgradeOpen", ); let mut req = request.into_request(); req.extensions_mut() .insert( - GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeConfirm"), + GrpcMethod::new("ibc.core.channel.v1.Msg", "ChannelUpgradeOpen"), ); self.inner.unary(req, path, codec).await } @@ -1431,12 +1480,12 @@ pub mod msg_server { tonic::Response, tonic::Status, >; - /// ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm. - async fn channel_upgrade_confirm( + /// ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen. + async fn channel_upgrade_open( &self, - request: tonic::Request, + request: tonic::Request, ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; /// ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. @@ -2110,25 +2159,25 @@ pub mod msg_server { }; Box::pin(fut) } - "/ibc.core.channel.v1.Msg/ChannelUpgradeConfirm" => { + "/ibc.core.channel.v1.Msg/ChannelUpgradeOpen" => { #[allow(non_camel_case_types)] - struct ChannelUpgradeConfirmSvc(pub Arc); + struct ChannelUpgradeOpenSvc(pub Arc); impl< T: Msg, - > tonic::server::UnaryService - for ChannelUpgradeConfirmSvc { - type Response = super::MsgChannelUpgradeConfirmResponse; + > 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 { - (*inner).channel_upgrade_confirm(request).await + (*inner).channel_upgrade_open(request).await }; Box::pin(fut) } @@ -2140,7 +2189,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = ChannelUpgradeConfirmSvc(inner); + let method = ChannelUpgradeOpenSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( From 9e0ecb6f3c4b736e3ff95e1518f19deeead1a675 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 20 Jun 2023 16:49:21 +0200 Subject: [PATCH 05/15] Fix post merge --- src/prost/ibc.core.channel.v1.rs | 170 ++++++++++++++++--------------- 1 file changed, 88 insertions(+), 82 deletions(-) diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 083dced7..c31fdc10 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -1,8 +1,11 @@ /// Channel defines pipeline for exactly-once packet delivery between specific /// modules on separate blockchains, which has at least one end capable of /// sending packets and one end capable of receiving packets. -#[derive(::serde::Serialize, ::serde::Deserialize)] -#[cfg_attr(feature = "json-schema", derive(::schemars::JsonSchema))] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr( + all(feature = "json-schema", feature = "std"), + derive(::schemars::JsonSchema) +)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Channel { @@ -32,7 +35,7 @@ pub struct Channel { } /// IdentifiedChannel defines a channel with additional port and channel /// identifier fields. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct IdentifiedChannel { @@ -60,8 +63,11 @@ pub struct IdentifiedChannel { pub channel_id: ::prost::alloc::string::String, } /// Counterparty defines a channel end counterparty -#[derive(::serde::Serialize, ::serde::Deserialize)] -#[cfg_attr(feature = "json-schema", derive(::schemars::JsonSchema))] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr( + all(feature = "json-schema", feature = "std"), + derive(::schemars::JsonSchema) +)] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Counterparty { @@ -73,7 +79,7 @@ pub struct Counterparty { pub channel_id: ::prost::alloc::string::String, } /// Packet defines a type that carries data across different chains through IBC -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Packet { @@ -108,7 +114,7 @@ pub struct Packet { /// packet commitments, acknowledgements, and receipts. /// Caller is responsible for knowing the context necessary to interpret this /// state as a commitment, acknowledgement, or a receipt. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketState { @@ -128,7 +134,7 @@ pub struct PacketState { /// PacketId is an identifer for a unique Packet /// Source chains refer to packets by source port/channel /// Destination chains refer to packets by destination port/channel -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketId { @@ -149,7 +155,7 @@ pub struct PacketId { /// The first byte of any message with this format will be the non-ASCII values /// `0xaa` (result) or `0xb2` (error). Implemented as defined by ICS: /// -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Acknowledgement { @@ -160,7 +166,7 @@ pub struct Acknowledgement { /// Nested message and enum types in `Acknowledgement`. pub mod acknowledgement { /// response contains either a result or an error and must be non-empty - #[derive(::serde::Serialize, ::serde::Deserialize)] + #[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Response { @@ -173,7 +179,7 @@ pub mod acknowledgement { /// Timeout defines an execution deadline structure for 04-channel handlers. /// This includes packet lifecycle handlers as well as the upgrade handshake handlers. /// A valid Timeout contains either one or both of a timestamp and block height (sequence). -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Timeout { @@ -186,7 +192,7 @@ pub struct Timeout { } /// State defines if a channel is in one of the following states: /// CLOSED, INIT, TRYOPEN, OPEN, INITUPGRADE, TRYUPGRADE or UNINITIALIZED. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { @@ -245,7 +251,7 @@ impl State { } } /// FlushStatus defines the status of a channel end pertaining to in-flight packets during an upgrade handshake. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum FlushStatus { @@ -279,7 +285,7 @@ impl FlushStatus { } } /// Order defines if a channel is ORDERED or UNORDERED -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Order { @@ -314,7 +320,7 @@ impl Order { } } /// GenesisState defines the ibc channel submodule's genesis state. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenesisState { @@ -338,7 +344,7 @@ pub struct GenesisState { } /// PacketSequence defines the genesis type necessary to retrieve and store /// next send and receive sequences. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketSequence { @@ -353,7 +359,7 @@ pub struct PacketSequence { /// for an attempted upgrade. It provides the proposed changes to the channel /// end, the timeout for this upgrade attempt and the latest packet sequence sent /// to allow the counterparty to block sends after the upgrade has started. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Upgrade { @@ -366,7 +372,7 @@ pub struct Upgrade { } /// UpgradeFields are the fields in a channel end which may be changed /// during a channel upgrade. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpgradeFields { @@ -380,7 +386,7 @@ pub struct UpgradeFields { /// 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. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ErrorReceipt { @@ -393,7 +399,7 @@ pub struct ErrorReceipt { } /// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It /// is called by a relayer on Chain A. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenInit { @@ -405,7 +411,7 @@ pub struct MsgChannelOpenInit { pub signer: ::prost::alloc::string::String, } /// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenInitResponse { @@ -417,7 +423,7 @@ pub struct MsgChannelOpenInitResponse { /// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel /// on Chain B. The version field within the Channel field has been deprecated. Its /// value will be ignored by core IBC. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenTry { @@ -440,7 +446,7 @@ pub struct MsgChannelOpenTry { pub signer: ::prost::alloc::string::String, } /// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenTryResponse { @@ -451,7 +457,7 @@ pub struct MsgChannelOpenTryResponse { } /// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge /// the change of channel state to TRYOPEN on Chain B. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenAck { @@ -471,13 +477,13 @@ pub struct MsgChannelOpenAck { pub signer: ::prost::alloc::string::String, } /// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenAckResponse {} /// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to /// acknowledge the change of channel state to OPEN on Chain A. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenConfirm { @@ -494,13 +500,13 @@ pub struct MsgChannelOpenConfirm { } /// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response /// type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenConfirmResponse {} /// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A /// to close a channel with Chain B. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseInit { @@ -512,13 +518,13 @@ pub struct MsgChannelCloseInit { pub signer: ::prost::alloc::string::String, } /// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseInitResponse {} /// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B /// to acknowledge the change of channel state to CLOSED on Chain A. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseConfirm { @@ -535,12 +541,12 @@ pub struct MsgChannelCloseConfirm { } /// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response /// type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseConfirmResponse {} /// MsgRecvPacket receives incoming IBC packet -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgRecvPacket { @@ -554,7 +560,7 @@ pub struct MsgRecvPacket { pub signer: ::prost::alloc::string::String, } /// MsgRecvPacketResponse defines the Msg/RecvPacket response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgRecvPacketResponse { @@ -562,7 +568,7 @@ pub struct MsgRecvPacketResponse { pub result: i32, } /// MsgTimeout receives timed-out packet -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeout { @@ -578,7 +584,7 @@ pub struct MsgTimeout { pub signer: ::prost::alloc::string::String, } /// MsgTimeoutResponse defines the Msg/Timeout response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutResponse { @@ -586,7 +592,7 @@ pub struct MsgTimeoutResponse { pub result: i32, } /// MsgTimeoutOnClose timed-out packet upon counterparty channel closure. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutOnClose { @@ -604,7 +610,7 @@ pub struct MsgTimeoutOnClose { pub signer: ::prost::alloc::string::String, } /// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutOnCloseResponse { @@ -612,7 +618,7 @@ pub struct MsgTimeoutOnCloseResponse { pub result: i32, } /// MsgAcknowledgement receives incoming IBC acknowledgement -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgAcknowledgement { @@ -628,7 +634,7 @@ pub struct MsgAcknowledgement { pub signer: ::prost::alloc::string::String, } /// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgAcknowledgementResponse { @@ -636,7 +642,7 @@ pub struct MsgAcknowledgementResponse { pub result: i32, } /// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInit { @@ -652,7 +658,7 @@ pub struct MsgChannelUpgradeInit { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInitResponse { @@ -664,7 +670,7 @@ pub struct MsgChannelUpgradeInitResponse { pub upgrade_sequence: u64, } /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTry { @@ -692,7 +698,7 @@ pub struct MsgChannelUpgradeTry { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTryResponse { @@ -706,7 +712,7 @@ pub struct MsgChannelUpgradeTryResponse { pub result: i32, } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeAck { @@ -728,7 +734,7 @@ pub struct MsgChannelUpgradeAck { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeAckResponse { @@ -736,7 +742,7 @@ pub struct MsgChannelUpgradeAckResponse { pub result: i32, } /// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeOpen { @@ -754,12 +760,12 @@ pub struct MsgChannelUpgradeOpen { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeOpenResponse {} /// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTimeout { @@ -781,7 +787,7 @@ pub struct MsgChannelUpgradeTimeout { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTimeoutResponse { @@ -789,7 +795,7 @@ pub struct MsgChannelUpgradeTimeoutResponse { pub result: i32, } /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeCancel { @@ -807,12 +813,12 @@ pub struct MsgChannelUpgradeCancel { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeCancelResponse {} /// ResponseResultType defines the possible outcomes of the execution of a message -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ResponseResultType { @@ -2339,7 +2345,7 @@ pub mod msg_server { } } /// QueryChannelRequest is the request type for the Query/Channel RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelRequest { @@ -2353,7 +2359,7 @@ pub struct QueryChannelRequest { /// QueryChannelResponse is the response type for the Query/Channel RPC method. /// Besides the Channel end, it includes a proof and the height from which the /// proof was retrieved. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelResponse { @@ -2368,7 +2374,7 @@ pub struct QueryChannelResponse { pub proof_height: ::core::option::Option, } /// QueryChannelsRequest is the request type for the Query/Channels RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelsRequest { @@ -2379,7 +2385,7 @@ pub struct QueryChannelsRequest { >, } /// QueryChannelsResponse is the response type for the Query/Channels RPC method. -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelsResponse { @@ -2397,7 +2403,7 @@ pub struct QueryChannelsResponse { } /// QueryConnectionChannelsRequest is the request type for the /// Query/QueryConnectionChannels RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryConnectionChannelsRequest { @@ -2412,7 +2418,7 @@ pub struct QueryConnectionChannelsRequest { } /// QueryConnectionChannelsResponse is the Response type for the /// Query/QueryConnectionChannels RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryConnectionChannelsResponse { @@ -2430,7 +2436,7 @@ pub struct QueryConnectionChannelsResponse { } /// QueryChannelClientStateRequest is the request type for the Query/ClientState /// RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelClientStateRequest { @@ -2443,7 +2449,7 @@ pub struct QueryChannelClientStateRequest { } /// QueryChannelClientStateResponse is the Response type for the /// Query/QueryChannelClientState RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelClientStateResponse { @@ -2461,7 +2467,7 @@ pub struct QueryChannelClientStateResponse { } /// QueryChannelConsensusStateRequest is the request type for the /// Query/ConsensusState RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelConsensusStateRequest { @@ -2480,7 +2486,7 @@ pub struct QueryChannelConsensusStateRequest { } /// QueryChannelClientStateResponse is the Response type for the /// Query/QueryChannelClientState RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelConsensusStateResponse { @@ -2501,7 +2507,7 @@ pub struct QueryChannelConsensusStateResponse { } /// QueryPacketCommitmentRequest is the request type for the /// Query/PacketCommitment RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentRequest { @@ -2518,7 +2524,7 @@ pub struct QueryPacketCommitmentRequest { /// QueryPacketCommitmentResponse defines the client query response for a packet /// which also includes a proof and the height from which the proof was /// retrieved -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentResponse { @@ -2534,7 +2540,7 @@ pub struct QueryPacketCommitmentResponse { } /// QueryPacketCommitmentsRequest is the request type for the /// Query/QueryPacketCommitments RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentsRequest { @@ -2552,7 +2558,7 @@ pub struct QueryPacketCommitmentsRequest { } /// QueryPacketCommitmentsResponse is the request type for the /// Query/QueryPacketCommitments RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentsResponse { @@ -2569,7 +2575,7 @@ pub struct QueryPacketCommitmentsResponse { } /// QueryPacketReceiptRequest is the request type for the /// Query/PacketReceipt RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketReceiptRequest { @@ -2586,7 +2592,7 @@ pub struct QueryPacketReceiptRequest { /// QueryPacketReceiptResponse defines the client query response for a packet /// receipt which also includes a proof, and the height from which the proof was /// retrieved -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketReceiptResponse { @@ -2602,7 +2608,7 @@ pub struct QueryPacketReceiptResponse { } /// QueryPacketAcknowledgementRequest is the request type for the /// Query/PacketAcknowledgement RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementRequest { @@ -2619,7 +2625,7 @@ pub struct QueryPacketAcknowledgementRequest { /// QueryPacketAcknowledgementResponse defines the client query response for a /// packet which also includes a proof and the height from which the /// proof was retrieved -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementResponse { @@ -2635,7 +2641,7 @@ pub struct QueryPacketAcknowledgementResponse { } /// QueryPacketAcknowledgementsRequest is the request type for the /// Query/QueryPacketCommitments RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementsRequest { @@ -2656,7 +2662,7 @@ pub struct QueryPacketAcknowledgementsRequest { } /// QueryPacketAcknowledgemetsResponse is the request type for the /// Query/QueryPacketAcknowledgements RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementsResponse { @@ -2673,7 +2679,7 @@ pub struct QueryPacketAcknowledgementsResponse { } /// QueryUnreceivedPacketsRequest is the request type for the /// Query/UnreceivedPackets RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedPacketsRequest { @@ -2689,7 +2695,7 @@ pub struct QueryUnreceivedPacketsRequest { } /// QueryUnreceivedPacketsResponse is the response type for the /// Query/UnreceivedPacketCommitments RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedPacketsResponse { @@ -2702,7 +2708,7 @@ pub struct QueryUnreceivedPacketsResponse { } /// QueryUnreceivedAcks is the request type for the /// Query/UnreceivedAcks RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedAcksRequest { @@ -2718,7 +2724,7 @@ pub struct QueryUnreceivedAcksRequest { } /// QueryUnreceivedAcksResponse is the response type for the /// Query/UnreceivedAcks RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedAcksResponse { @@ -2731,7 +2737,7 @@ pub struct QueryUnreceivedAcksResponse { } /// QueryNextSequenceReceiveRequest is the request type for the /// Query/QueryNextSequenceReceiveRequest RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceReceiveRequest { @@ -2744,7 +2750,7 @@ pub struct QueryNextSequenceReceiveRequest { } /// QuerySequenceResponse is the response type for the /// Query/QueryNextSequenceReceiveResponse RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceReceiveResponse { @@ -2759,7 +2765,7 @@ pub struct QueryNextSequenceReceiveResponse { pub proof_height: ::core::option::Option, } /// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeErrorRequest { @@ -2769,7 +2775,7 @@ pub struct QueryUpgradeErrorRequest { pub channel_id: ::prost::alloc::string::String, } /// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeErrorResponse { @@ -2783,7 +2789,7 @@ pub struct QueryUpgradeErrorResponse { pub proof_height: ::core::option::Option, } /// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeRequest { @@ -2793,7 +2799,7 @@ pub struct QueryUpgradeRequest { pub channel_id: ::prost::alloc::string::String, } /// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method -#[derive(::serde::Serialize, ::serde::Deserialize)] +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeResponse { From b3d0320ead537ed528bb76b45fe49b8e4ca00c75 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 8 Aug 2023 09:22:17 +0200 Subject: [PATCH 06/15] Update channel-upgradability commit --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 14 +++++++++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index bfbc0831..14eb758a 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -6453bd4af5ec3fc28811fc91d4ad09e871ebd4ef +9886cbd60e06fbd2d552e3d0dba4656f40d4692d diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index c31fdc10..18a1a37a 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -208,15 +208,19 @@ 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, /// A channel has just started the channel upgrade handshake. /// The chain that is proposing the upgrade should set the channel state from OPEN to UPGRADEINIT. - Initupgrade = 5, + Initupgrade = 7, /// A channel has acknowledged the upgrade handshake step on the counterparty chain. /// The counterparty chain that accepts the upgrade should set the channel state from OPEN to UPGRADETRY. - Tryupgrade = 6, + Tryupgrade = 8, /// A channel has verified the counterparty chain is in UPGRADETRY. /// However, there are still in-flight packets on both ends waiting to be flushed before it can move to OPEN. - Ackupgrade = 7, + Ackupgrade = 9, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -230,6 +234,8 @@ impl State { State::Tryopen => "STATE_TRYOPEN", State::Open => "STATE_OPEN", State::Closed => "STATE_CLOSED", + State::Flushing => "STATE_FLUSHING", + State::Flushcomplete => "STATE_FLUSHCOMPLETE", State::Initupgrade => "STATE_INITUPGRADE", State::Tryupgrade => "STATE_TRYUPGRADE", State::Ackupgrade => "STATE_ACKUPGRADE", @@ -243,6 +249,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), "STATE_INITUPGRADE" => Some(Self::Initupgrade), "STATE_TRYUPGRADE" => Some(Self::Tryupgrade), "STATE_ACKUPGRADE" => Some(Self::Ackupgrade), From a3cad9102eeae2d356054b2a5c55298213f9405d Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 23 Aug 2023 17:09:13 +0200 Subject: [PATCH 07/15] Update channel upgrade protos with latest commit --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 247 +++++++++++++++++++++++++++++-- 2 files changed, 233 insertions(+), 16 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 14eb758a..f745497c 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -9886cbd60e06fbd2d552e3d0dba4656f40d4692d +f1e8ae805a3633d47928cfc02315a1a19ca80a0e diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 18a1a37a..6481dd89 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -660,9 +660,7 @@ pub struct MsgChannelUpgradeInit { pub channel_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] pub fields: ::core::option::Option, - #[prost(message, optional, tag = "4")] - pub timeout: ::core::option::Option, - #[prost(string, tag = "5")] + #[prost(string, tag = "4")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type @@ -691,18 +689,16 @@ pub struct MsgChannelUpgradeTry { ::prost::alloc::string::String, >, #[prost(message, optional, tag = "4")] - pub upgrade_timeout: ::core::option::Option, - #[prost(message, optional, tag = "5")] - pub counterparty_proposed_upgrade: ::core::option::Option, - #[prost(uint64, tag = "6")] + pub counterparty_upgrade_fields: ::core::option::Option, + #[prost(uint64, tag = "5")] pub counterparty_upgrade_sequence: u64, - #[prost(bytes = "vec", tag = "7")] + #[prost(bytes = "vec", tag = "6")] pub proof_channel: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "8")] + #[prost(bytes = "vec", tag = "7")] pub proof_upgrade: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "9")] + #[prost(message, optional, tag = "8")] pub proof_height: ::core::option::Option, - #[prost(string, tag = "10")] + #[prost(string, tag = "9")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type @@ -728,8 +724,36 @@ pub struct MsgChannelUpgradeAck { pub port_id: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, - #[prost(enumeration = "FlushStatus", tag = "3")] - pub counterparty_flush_status: i32, + #[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, +} +/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAckResponse { + #[prost(enumeration = "ResponseResultType", tag = "1")] + pub result: i32, +} +/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[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")] @@ -741,11 +765,11 @@ pub struct MsgChannelUpgradeAck { #[prost(string, tag = "8")] pub signer: ::prost::alloc::string::String, } -/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type +/// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type #[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeAckResponse { +pub struct MsgChannelUpgradeConfirmResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } @@ -1295,6 +1319,34 @@ pub mod msg_client { .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, @@ -1494,6 +1546,14 @@ pub mod msg_server { 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, @@ -2173,6 +2233,52 @@ pub mod msg_server { }; 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 ChannelUpgradeConfirmSvc { + type Response = super::MsgChannelUpgradeConfirmResponse; + 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 { + (*inner).channel_upgrade_confirm(request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelUpgradeConfirmSvc(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/ChannelUpgradeOpen" => { #[allow(non_camel_case_types)] struct ChannelUpgradeOpenSvc(pub Arc); @@ -2772,6 +2878,35 @@ pub struct QueryNextSequenceReceiveResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +/// QueryNextSequenceSendRequest is the request type for the +/// Query/QueryNextSequenceSend RPC method +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendRequest { + /// port unique identifier + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, +} +/// QueryNextSequenceSendResponse is the request type for the +/// Query/QueryNextSequenceSend RPC method +#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendResponse { + /// next sequence send number + #[prost(uint64, tag = "1")] + pub next_sequence_send: u64, + /// 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, +} /// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method #[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] @@ -3274,6 +3409,34 @@ pub mod query_client { ); self.inner.unary(req, path, codec).await } + /// NextSequenceSend returns the next send sequence for a given channel. + pub async fn next_sequence_send( + &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/NextSequenceSend", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Query", "NextSequenceSend"), + ); + self.inner.unary(req, path, codec).await + } /// UpgradeError returns the error receipt if the upgrade handshake failed. pub async fn upgrade_error( &mut self, @@ -3448,6 +3611,14 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// NextSequenceSend returns the next send sequence for a given channel. + async fn next_sequence_send( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; /// UpgradeError returns the error receipt if the upgrade handshake failed. async fn upgrade_error( &self, @@ -4154,6 +4325,52 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Query/NextSequenceSend" => { + #[allow(non_camel_case_types)] + struct NextSequenceSendSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for NextSequenceSendSvc { + type Response = super::QueryNextSequenceSendResponse; + 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 { + (*inner).next_sequence_send(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 = NextSequenceSendSvc(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/UpgradeError" => { #[allow(non_camel_case_types)] struct UpgradeErrorSvc(pub Arc); From f2745837ae445d431e8e48e5fd0bef14b2cf4585 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Tue, 10 Oct 2023 16:31:55 +0200 Subject: [PATCH 08/15] Update channel upgrade protos only with alpha tagged ibc-go --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 246 +++++++++++++++++++------------ 2 files changed, 152 insertions(+), 96 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index f745497c..0479b717 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -f1e8ae805a3633d47928cfc02315a1a19ca80a0e +63c30108f0ecf954108cf51f50f3d36ec58c7e51 diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 2e771934..9e13647a 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -29,9 +29,6 @@ pub struct Channel { /// the value of 0 indicates the channel has never been upgraded #[prost(uint64, tag = "6")] pub upgrade_sequence: u64, - /// flush status indicates the current status of inflight packet flushing on the channel end - #[prost(enumeration = "FlushStatus", tag = "7")] - pub flush_status: i32, } /// IdentifiedChannel defines a channel with additional port and channel /// identifier fields. @@ -179,7 +176,7 @@ pub mod acknowledgement { /// Timeout defines an execution deadline structure for 04-channel handlers. /// This includes packet lifecycle handlers as well as the upgrade handshake handlers. /// A valid Timeout contains either one or both of a timestamp and block height (sequence). -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Timeout { @@ -190,9 +187,18 @@ pub struct Timeout { #[prost(uint64, tag = "2")] pub timestamp: u64, } +/// Params defines the set of IBC channel parameters. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[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, +} /// State defines if a channel is in one of the following states: -/// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED. -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +/// CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { @@ -212,15 +218,6 @@ pub enum State { Flushing = 5, /// A channel has just completed flushing any in-flight packets. Flushcomplete = 6, - /// A channel has just started the channel upgrade handshake. - /// The chain that is proposing the upgrade should set the channel state from OPEN to UPGRADEINIT. - Initupgrade = 7, - /// A channel has acknowledged the upgrade handshake step on the counterparty chain. - /// The counterparty chain that accepts the upgrade should set the channel state from OPEN to UPGRADETRY. - Tryupgrade = 8, - /// A channel has verified the counterparty chain is in UPGRADETRY. - /// However, there are still in-flight packets on both ends waiting to be flushed before it can move to OPEN. - Ackupgrade = 9, } impl State { /// String value of the enum field names used in the ProtoBuf definition. @@ -236,9 +233,6 @@ impl State { State::Closed => "STATE_CLOSED", State::Flushing => "STATE_FLUSHING", State::Flushcomplete => "STATE_FLUSHCOMPLETE", - State::Initupgrade => "STATE_INITUPGRADE", - State::Tryupgrade => "STATE_TRYUPGRADE", - State::Ackupgrade => "STATE_ACKUPGRADE", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -251,43 +245,6 @@ impl State { "STATE_CLOSED" => Some(Self::Closed), "STATE_FLUSHING" => Some(Self::Flushing), "STATE_FLUSHCOMPLETE" => Some(Self::Flushcomplete), - "STATE_INITUPGRADE" => Some(Self::Initupgrade), - "STATE_TRYUPGRADE" => Some(Self::Tryupgrade), - "STATE_ACKUPGRADE" => Some(Self::Ackupgrade), - _ => None, - } - } -} -/// FlushStatus defines the status of a channel end pertaining to in-flight packets during an upgrade handshake. -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum FlushStatus { - /// Default status, the channel is not in an upgrade handshake - NotinflushUnspecified = 0, - /// The channel end is flushing in-flight packets - Flushing = 1, - /// There are no in-flight packets left and the channel end is ready to move to OPEN - Flushcomplete = 2, -} -impl FlushStatus { - /// 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 { - FlushStatus::NotinflushUnspecified => "FLUSH_STATUS_NOTINFLUSH_UNSPECIFIED", - FlushStatus::Flushing => "FLUSH_STATUS_FLUSHING", - FlushStatus::Flushcomplete => "FLUSH_STATUS_FLUSHCOMPLETE", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "FLUSH_STATUS_NOTINFLUSH_UNSPECIFIED" => Some(Self::NotinflushUnspecified), - "FLUSH_STATUS_FLUSHING" => Some(Self::Flushing), - "FLUSH_STATUS_FLUSHCOMPLETE" => Some(Self::Flushcomplete), _ => None, } } @@ -349,6 +306,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, } /// PacketSequence defines the genesis type necessary to retrieve and store /// next send and receive sequences. @@ -367,7 +326,7 @@ pub struct PacketSequence { /// for an attempted upgrade. It provides the proposed changes to the channel /// end, the timeout for this upgrade attempt and the latest packet sequence sent /// to allow the counterparty to block sends after the upgrade has started. -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Upgrade { @@ -380,7 +339,7 @@ pub struct Upgrade { } /// UpgradeFields are the fields in a channel end which may be changed /// during a channel upgrade. -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpgradeFields { @@ -394,7 +353,7 @@ pub struct UpgradeFields { /// 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. -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ErrorReceipt { @@ -650,7 +609,7 @@ pub struct MsgAcknowledgementResponse { pub result: i32, } /// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInit { @@ -664,7 +623,7 @@ pub struct MsgChannelUpgradeInit { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInitResponse { @@ -676,7 +635,7 @@ pub struct MsgChannelUpgradeInitResponse { pub upgrade_sequence: u64, } /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTry { @@ -702,7 +661,7 @@ pub struct MsgChannelUpgradeTry { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTryResponse { @@ -716,7 +675,7 @@ pub struct MsgChannelUpgradeTryResponse { pub result: i32, } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeAck { @@ -736,7 +695,7 @@ pub struct MsgChannelUpgradeAck { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeAckResponse { @@ -744,7 +703,7 @@ pub struct MsgChannelUpgradeAckResponse { pub result: i32, } /// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeConfirm { @@ -766,7 +725,7 @@ pub struct MsgChannelUpgradeConfirm { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeConfirmResponse { @@ -774,7 +733,7 @@ pub struct MsgChannelUpgradeConfirmResponse { pub result: i32, } /// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeOpen { @@ -792,12 +751,12 @@ pub struct MsgChannelUpgradeOpen { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeOpenResponse {} /// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTimeout { @@ -807,19 +766,15 @@ pub struct MsgChannelUpgradeTimeout { pub channel_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] pub counterparty_channel: ::core::option::Option, - #[prost(message, optional, tag = "4")] - pub previous_error_receipt: ::core::option::Option, - #[prost(bytes = "vec", tag = "5")] + #[prost(bytes = "vec", tag = "4")] pub proof_channel: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "6")] - pub proof_error_receipt: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "7")] + #[prost(message, optional, tag = "5")] pub proof_height: ::core::option::Option, - #[prost(string, tag = "8")] + #[prost(string, tag = "6")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTimeoutResponse { @@ -827,7 +782,7 @@ pub struct MsgChannelUpgradeTimeoutResponse { pub result: i32, } /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeCancel { @@ -845,10 +800,29 @@ pub struct MsgChannelUpgradeCancel { pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeCancelResponse {} +/// MsgUpdateParams is the MsgUpdateParams request type. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[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, +} +/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse {} /// ResponseResultType defines the possible outcomes of the execution of a message #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -1431,6 +1405,34 @@ pub mod msg_client { ); 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 + } } } /// Generated server implementations. @@ -1578,6 +1580,14 @@ pub mod msg_server { tonic::Response, tonic::Status, >; + /// UpdateChannelParams defines a rpc handler method for MsgUpdateParams. + async fn update_channel_params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Msg defines the ibc/channel Msg service. #[derive(Debug)] @@ -2121,7 +2131,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_init(request).await + ::channel_upgrade_init(&inner, request).await }; Box::pin(fut) } @@ -2165,7 +2175,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_try(request).await + ::channel_upgrade_try(&inner, request).await }; Box::pin(fut) } @@ -2209,7 +2219,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_ack(request).await + ::channel_upgrade_ack(&inner, request).await }; Box::pin(fut) } @@ -2255,7 +2265,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_confirm(request).await + ::channel_upgrade_confirm(&inner, request).await }; Box::pin(fut) } @@ -2301,7 +2311,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_open(request).await + ::channel_upgrade_open(&inner, request).await }; Box::pin(fut) } @@ -2347,7 +2357,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_timeout(request).await + ::channel_upgrade_timeout(&inner, request).await }; Box::pin(fut) } @@ -2393,7 +2403,7 @@ pub mod msg_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).channel_upgrade_cancel(request).await + ::channel_upgrade_cancel(&inner, request).await }; Box::pin(fut) } @@ -2421,6 +2431,50 @@ pub mod msg_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Msg/UpdateChannelParams" => { + #[allow(non_camel_case_types)] + 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, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_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 = 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) + } _ => { Box::pin(async move { Ok( @@ -2884,7 +2938,7 @@ pub struct QueryNextSequenceReceiveResponse { } /// QueryNextSequenceSendRequest is the request type for the /// Query/QueryNextSequenceSend RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceSendRequest { @@ -2897,7 +2951,7 @@ pub struct QueryNextSequenceSendRequest { } /// QueryNextSequenceSendResponse is the request type for the /// Query/QueryNextSequenceSend RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceSendResponse { @@ -2912,7 +2966,7 @@ pub struct QueryNextSequenceSendResponse { pub proof_height: ::core::option::Option, } /// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeErrorRequest { @@ -2922,7 +2976,7 @@ pub struct QueryUpgradeErrorRequest { pub channel_id: ::prost::alloc::string::String, } /// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeErrorResponse { @@ -2936,7 +2990,7 @@ pub struct QueryUpgradeErrorResponse { pub proof_height: ::core::option::Option, } /// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeRequest { @@ -2946,7 +3000,7 @@ pub struct QueryUpgradeRequest { pub channel_id: ::prost::alloc::string::String, } /// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method -#[cfg_attr(feature = "std", derive(::serde::Serialize, ::serde::Deserialize))] +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUpgradeResponse { @@ -4351,7 +4405,7 @@ pub mod query_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).next_sequence_send(request).await + ::next_sequence_send(&inner, request).await }; Box::pin(fut) } @@ -4397,7 +4451,7 @@ pub mod query_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).upgrade_error(request).await + ::upgrade_error(&inner, request).await }; Box::pin(fut) } @@ -4442,7 +4496,9 @@ pub mod query_server { request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); - let fut = async move { (*inner).upgrade(request).await }; + let fut = async move { + ::upgrade(&inner, request).await + }; Box::pin(fut) } } From 364e997d48b99ce27b177fea30c0734545e17703 Mon Sep 17 00:00:00 2001 From: Carlos Rodriguez Date: Tue, 9 Jan 2024 09:21:31 +0100 Subject: [PATCH 09/15] sync ibc-go with tag `04-channel-upgrades-rc.0` (#179) --- src/IBC_GO_COMMIT | 2 +- src/lib.rs | 6 +- src/prost/google.protobuf.rs | 640 +++++++++++++++++++++++++++++-- src/prost/ibc.core.channel.v1.rs | 236 +++++++++++- src/prost/proto_descriptor.bin | Bin 702918 -> 737265 bytes 5 files changed, 842 insertions(+), 42 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 47f08cce..8c33106a 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -2551dea41cd3c512845007ca895c8402afa9b79f +7a89e5d5b5ebb7643ce3992c34008c35373ecf34 diff --git a/src/lib.rs b/src/lib.rs index 4287448b..5abf7bf4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,7 +5,11 @@ #![cfg_attr(not(feature = "std"), no_std)] #![deny(warnings, trivial_casts, trivial_numeric_casts, unused_import_braces)] -#![allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)] +#![allow( + clippy::large_enum_variant, + clippy::derive_partial_eq_without_eq, + clippy::needless_borrows_for_generic_args +)] #![allow(rustdoc::bare_urls)] #![forbid(unsafe_code)] diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 3878889e..33731f49 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -22,8 +22,12 @@ /// if (any.is(Foo.class)) { /// foo = any.unpack(Foo.class); /// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } /// -/// Example 3: Pack and unpack a message in Python. +/// Example 3: Pack and unpack a message in Python. /// /// foo = Foo(...) /// any = Any() @@ -33,7 +37,7 @@ /// any.Unpack(foo) /// ... /// -/// Example 4: Pack and unpack a message in Go +/// Example 4: Pack and unpack a message in Go /// /// foo := &pb.Foo{...} /// any, err := anypb.New(foo) @@ -52,9 +56,8 @@ /// in the type URL, for example "foo.bar.com/x/y.z" will yield type /// name "y.z". /// -/// /// JSON -/// +/// ==== /// The JSON representation of an `Any` value uses the regular /// representation of the deserialized, embedded message, with an /// additional field `@type` which contains the type URL. Example: @@ -113,7 +116,8 @@ pub struct Any { /// /// Note: this functionality is not currently available in the official /// protobuf release, and it is not used for type URLs beginning with - /// type.googleapis.com. + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. /// /// Schemes other than `http`, `https` (or the empty scheme) might be /// used with implementation specific semantics. @@ -170,9 +174,14 @@ pub struct FileDescriptorProto { #[prost(message, optional, tag = "9")] pub source_code_info: ::core::option::Option, /// The syntax of the proto file. - /// The supported values are "proto2" and "proto3". + /// The supported values are "proto2", "proto3", and "editions". + /// + /// If `edition` is present, this value must be "editions". #[prost(string, optional, tag = "12")] pub syntax: ::core::option::Option<::prost::alloc::string::String>, + /// The edition of the proto file, which is an opaque string. + #[prost(string, optional, tag = "13")] + pub edition: ::core::option::Option<::prost::alloc::string::String>, } /// Describes a message type. #[allow(clippy::derive_partial_eq_without_eq)] @@ -235,6 +244,90 @@ pub struct ExtensionRangeOptions { /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + #[prost(message, repeated, tag = "2")] + pub declaration: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "50")] + pub features: ::core::option::Option, + /// The verification state of the range. + /// TODO(b/278783756): flip the default to DECLARATION once all empty ranges + /// are marked as UNVERIFIED. + #[prost( + enumeration = "extension_range_options::VerificationState", + optional, + tag = "3", + default = "Unverified" + )] + pub verification: ::core::option::Option, +} +/// Nested message and enum types in `ExtensionRangeOptions`. +pub mod extension_range_options { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Declaration { + /// The extension number declared within the extension range. + #[prost(int32, optional, tag = "1")] + pub number: ::core::option::Option, + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + #[prost(string, optional, tag = "2")] + pub full_name: ::core::option::Option<::prost::alloc::string::String>, + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + #[prost(string, optional, tag = "3")] + pub r#type: ::core::option::Option<::prost::alloc::string::String>, + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + #[prost(bool, optional, tag = "5")] + pub reserved: ::core::option::Option, + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + #[prost(bool, optional, tag = "6")] + pub repeated: ::core::option::Option, + } + /// The verification state of the extension range. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum VerificationState { + /// All the extensions of the range must be declared. + Declaration = 0, + Unverified = 1, + } + impl VerificationState { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + VerificationState::Declaration => "DECLARATION", + VerificationState::Unverified => "UNVERIFIED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DECLARATION" => Some(Self::Declaration), + "UNVERIFIED" => Some(Self::Unverified), + _ => None, + } + } + } } /// Describes a field within a message. #[allow(clippy::derive_partial_eq_without_eq)] @@ -647,6 +740,9 @@ pub struct FileOptions { /// determining the ruby package. #[prost(string, optional, tag = "45")] pub ruby_package: ::core::option::Option<::prost::alloc::string::String>, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "50")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. /// See the documentation for the "Options" section above. #[prost(message, repeated, tag = "999")] @@ -734,6 +830,10 @@ pub struct MessageOptions { /// this is a formalization for deprecating messages. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, + /// NOTE: Do not set the option in .proto files. Always use the maps syntax + /// instead. The option should only be implicitly set by the proto compiler + /// parser. + /// /// Whether the message is an automatically generated map entry type for the /// maps field. /// @@ -751,12 +851,24 @@ pub struct MessageOptions { /// use a native map in the target language to hold the keys and values. /// The reflection APIs in such implementations still need to work as /// if the field is a repeated message field. - /// - /// NOTE: Do not set the option in .proto files. Always use the maps syntax - /// instead. The option should only be implicitly set by the proto compiler - /// parser. #[prost(bool, optional, tag = "7")] pub map_entry: ::core::option::Option, + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// + /// This should only be used as a temporary measure against broken builds due + /// to the change in behavior for JSON field name conflicts. + /// + /// TODO(b/261750190) This is legacy behavior we plan to remove once downstream + /// teams have had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "11")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "12")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -766,8 +878,10 @@ pub struct MessageOptions { pub struct FieldOptions { /// The ctype option instructs the C++ code generator to use a different /// representation of the field than it normally would. See the specific - /// options below. This option is not yet implemented in the open source - /// release -- sorry, we'll try to include it in a future version! + /// options below. This option is only implemented to support use of + /// \[ctype=CORD\] and \[ctype=STRING\] (the default) on non-repeated fields of + /// type "bytes" in the open source release -- sorry, we'll try to include + /// other types in a future version! #[prost( enumeration = "field_options::CType", optional, @@ -817,7 +931,6 @@ pub struct FieldOptions { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// /// Note that implementations may choose not to check required fields within /// a lazy sub-message. That is, calling IsInitialized() on the outer message /// may return true even if the inner message has missing required fields. @@ -829,11 +942,8 @@ pub struct FieldOptions { /// check its required fields, regardless of whether or not the message has /// been parsed. /// - /// As of 2021, lazy does no correctness checks on the byte stream during - /// parsing. This may lead to crashes if and when an invalid byte stream is - /// finally parsed upon access. - /// - /// TODO(b/211906113): Enable validation on lazy fields. + /// As of May 2022, lazy verifies the contents of the byte stream during + /// parsing. An invalid byte stream will cause the overall parsing to fail. #[prost(bool, optional, tag = "5", default = "false")] pub lazy: ::core::option::Option, /// unverified_lazy does no correctness checks on the byte stream. This should @@ -850,12 +960,39 @@ pub struct FieldOptions { /// For Google-internal migration only. Do not use. #[prost(bool, optional, tag = "10", default = "false")] pub weak: ::core::option::Option, + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + #[prost(bool, optional, tag = "16", default = "false")] + pub debug_redact: ::core::option::Option, + #[prost(enumeration = "field_options::OptionRetention", optional, tag = "17")] + pub retention: ::core::option::Option, + #[prost( + enumeration = "field_options::OptionTargetType", + repeated, + packed = "false", + tag = "19" + )] + pub targets: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "20")] + pub edition_defaults: ::prost::alloc::vec::Vec, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "21")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `FieldOptions`. pub mod field_options { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct EditionDefault { + #[prost(string, optional, tag = "1")] + pub edition: ::core::option::Option<::prost::alloc::string::String>, + /// Textproto value. + #[prost(string, optional, tag = "2")] + pub value: ::core::option::Option<::prost::alloc::string::String>, + } #[derive( Clone, Copy, @@ -871,6 +1008,12 @@ pub mod field_options { pub enum CType { /// Default mode. String = 0, + /// The option \[ctype=CORD\] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. Cord = 1, StringPiece = 2, } @@ -938,10 +1081,121 @@ pub mod field_options { } } } + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + /// Note: as of January 2023, support for this is in progress and does not yet + /// have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionRetention { + RetentionUnknown = 0, + RetentionRuntime = 1, + RetentionSource = 2, + } + impl OptionRetention { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OptionRetention::RetentionUnknown => "RETENTION_UNKNOWN", + OptionRetention::RetentionRuntime => "RETENTION_RUNTIME", + OptionRetention::RetentionSource => "RETENTION_SOURCE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RETENTION_UNKNOWN" => Some(Self::RetentionUnknown), + "RETENTION_RUNTIME" => Some(Self::RetentionRuntime), + "RETENTION_SOURCE" => Some(Self::RetentionSource), + _ => None, + } + } + } + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. Note: as of January 2023, support for this is + /// in progress and does not yet have an effect (b/264593489). + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum OptionTargetType { + TargetTypeUnknown = 0, + TargetTypeFile = 1, + TargetTypeExtensionRange = 2, + TargetTypeMessage = 3, + TargetTypeField = 4, + TargetTypeOneof = 5, + TargetTypeEnum = 6, + TargetTypeEnumEntry = 7, + TargetTypeService = 8, + TargetTypeMethod = 9, + } + impl OptionTargetType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + OptionTargetType::TargetTypeUnknown => "TARGET_TYPE_UNKNOWN", + OptionTargetType::TargetTypeFile => "TARGET_TYPE_FILE", + OptionTargetType::TargetTypeExtensionRange => { + "TARGET_TYPE_EXTENSION_RANGE" + } + OptionTargetType::TargetTypeMessage => "TARGET_TYPE_MESSAGE", + OptionTargetType::TargetTypeField => "TARGET_TYPE_FIELD", + OptionTargetType::TargetTypeOneof => "TARGET_TYPE_ONEOF", + OptionTargetType::TargetTypeEnum => "TARGET_TYPE_ENUM", + OptionTargetType::TargetTypeEnumEntry => "TARGET_TYPE_ENUM_ENTRY", + OptionTargetType::TargetTypeService => "TARGET_TYPE_SERVICE", + OptionTargetType::TargetTypeMethod => "TARGET_TYPE_METHOD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TARGET_TYPE_UNKNOWN" => Some(Self::TargetTypeUnknown), + "TARGET_TYPE_FILE" => Some(Self::TargetTypeFile), + "TARGET_TYPE_EXTENSION_RANGE" => Some(Self::TargetTypeExtensionRange), + "TARGET_TYPE_MESSAGE" => Some(Self::TargetTypeMessage), + "TARGET_TYPE_FIELD" => Some(Self::TargetTypeField), + "TARGET_TYPE_ONEOF" => Some(Self::TargetTypeOneof), + "TARGET_TYPE_ENUM" => Some(Self::TargetTypeEnum), + "TARGET_TYPE_ENUM_ENTRY" => Some(Self::TargetTypeEnumEntry), + "TARGET_TYPE_SERVICE" => Some(Self::TargetTypeService), + "TARGET_TYPE_METHOD" => Some(Self::TargetTypeMethod), + _ => None, + } + } + } } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct OneofOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "1")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -959,6 +1213,18 @@ pub struct EnumOptions { /// is a formalization for deprecating enums. #[prost(bool, optional, tag = "3", default = "false")] pub deprecated: ::core::option::Option, + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// TODO(b/261750190) Remove this legacy behavior once downstream teams have + /// had time to migrate. + #[deprecated] + #[prost(bool, optional, tag = "6")] + pub deprecated_legacy_json_field_conflicts: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "7")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -972,6 +1238,14 @@ pub struct EnumValueOptions { /// this is a formalization for deprecating enum values. #[prost(bool, optional, tag = "1", default = "false")] pub deprecated: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "2")] + pub features: ::core::option::Option, + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + #[prost(bool, optional, tag = "3", default = "false")] + pub debug_redact: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -979,6 +1253,9 @@ pub struct EnumValueOptions { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ServiceOptions { + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "34")] + pub features: ::core::option::Option, /// Is this service deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for the service, or it will be completely ignored; in the very least, @@ -1005,6 +1282,9 @@ pub struct MethodOptions { default = "IdempotencyUnknown" )] pub idempotency_level: ::core::option::Option, + /// Any features defined in the specific edition. + #[prost(message, optional, tag = "35")] + pub features: ::core::option::Option, /// The parser stores options it doesn't recognize here. See above. #[prost(message, repeated, tag = "999")] pub uninterpreted_option: ::prost::alloc::vec::Vec, @@ -1098,6 +1378,273 @@ pub mod uninterpreted_option { pub is_extension: bool, } } +/// TODO(b/274655146) Enums in C++ gencode (and potentially other languages) are +/// not well scoped. This means that each of the feature enums below can clash +/// with each other. The short names we've chosen maximize call-site +/// readability, but leave us very open to this scenario. A future feature will +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeatureSet { + #[prost(enumeration = "feature_set::FieldPresence", optional, tag = "1")] + pub field_presence: ::core::option::Option, + #[prost(enumeration = "feature_set::EnumType", optional, tag = "2")] + pub enum_type: ::core::option::Option, + #[prost(enumeration = "feature_set::RepeatedFieldEncoding", optional, tag = "3")] + pub repeated_field_encoding: ::core::option::Option, + #[prost(enumeration = "feature_set::StringFieldValidation", optional, tag = "4")] + pub string_field_validation: ::core::option::Option, + #[prost(enumeration = "feature_set::MessageEncoding", optional, tag = "5")] + pub message_encoding: ::core::option::Option, + #[prost(enumeration = "feature_set::JsonFormat", optional, tag = "6")] + pub json_format: ::core::option::Option, + #[prost(message, optional, boxed, tag = "999")] + pub raw_features: ::core::option::Option<::prost::alloc::boxed::Box>, +} +/// Nested message and enum types in `FeatureSet`. +pub mod feature_set { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum FieldPresence { + Unknown = 0, + Explicit = 1, + Implicit = 2, + LegacyRequired = 3, + } + impl FieldPresence { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + FieldPresence::Unknown => "FIELD_PRESENCE_UNKNOWN", + FieldPresence::Explicit => "EXPLICIT", + FieldPresence::Implicit => "IMPLICIT", + FieldPresence::LegacyRequired => "LEGACY_REQUIRED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FIELD_PRESENCE_UNKNOWN" => Some(Self::Unknown), + "EXPLICIT" => Some(Self::Explicit), + "IMPLICIT" => Some(Self::Implicit), + "LEGACY_REQUIRED" => Some(Self::LegacyRequired), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum EnumType { + Unknown = 0, + Open = 1, + Closed = 2, + } + impl EnumType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + EnumType::Unknown => "ENUM_TYPE_UNKNOWN", + EnumType::Open => "OPEN", + EnumType::Closed => "CLOSED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ENUM_TYPE_UNKNOWN" => Some(Self::Unknown), + "OPEN" => Some(Self::Open), + "CLOSED" => Some(Self::Closed), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum RepeatedFieldEncoding { + Unknown = 0, + Packed = 1, + Expanded = 2, + } + impl RepeatedFieldEncoding { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + RepeatedFieldEncoding::Unknown => "REPEATED_FIELD_ENCODING_UNKNOWN", + RepeatedFieldEncoding::Packed => "PACKED", + RepeatedFieldEncoding::Expanded => "EXPANDED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "REPEATED_FIELD_ENCODING_UNKNOWN" => Some(Self::Unknown), + "PACKED" => Some(Self::Packed), + "EXPANDED" => Some(Self::Expanded), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum StringFieldValidation { + Unknown = 0, + Mandatory = 1, + Hint = 2, + None = 3, + } + impl StringFieldValidation { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + StringFieldValidation::Unknown => "STRING_FIELD_VALIDATION_UNKNOWN", + StringFieldValidation::Mandatory => "MANDATORY", + StringFieldValidation::Hint => "HINT", + StringFieldValidation::None => "NONE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "STRING_FIELD_VALIDATION_UNKNOWN" => Some(Self::Unknown), + "MANDATORY" => Some(Self::Mandatory), + "HINT" => Some(Self::Hint), + "NONE" => Some(Self::None), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum MessageEncoding { + Unknown = 0, + LengthPrefixed = 1, + Delimited = 2, + } + impl MessageEncoding { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + MessageEncoding::Unknown => "MESSAGE_ENCODING_UNKNOWN", + MessageEncoding::LengthPrefixed => "LENGTH_PREFIXED", + MessageEncoding::Delimited => "DELIMITED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MESSAGE_ENCODING_UNKNOWN" => Some(Self::Unknown), + "LENGTH_PREFIXED" => Some(Self::LengthPrefixed), + "DELIMITED" => Some(Self::Delimited), + _ => None, + } + } + } + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum JsonFormat { + Unknown = 0, + Allow = 1, + LegacyBestEffort = 2, + } + impl JsonFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JsonFormat::Unknown => "JSON_FORMAT_UNKNOWN", + JsonFormat::Allow => "ALLOW", + JsonFormat::LegacyBestEffort => "LEGACY_BEST_EFFORT", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "JSON_FORMAT_UNKNOWN" => Some(Self::Unknown), + "ALLOW" => Some(Self::Allow), + "LEGACY_BEST_EFFORT" => Some(Self::LegacyBestEffort), + _ => None, + } + } + } +} /// Encapsulates information about the original source file from which a /// FileDescriptorProto was generated. #[allow(clippy::derive_partial_eq_without_eq)] @@ -1271,10 +1818,59 @@ pub mod generated_code_info { #[prost(int32, optional, tag = "3")] pub begin: ::core::option::Option, /// Identifies the ending offset in bytes in the generated code that - /// relates to the identified offset. The end offset should be one past + /// relates to the identified object. The end offset should be one past /// the last relevant byte (so the length of the text = end - begin). #[prost(int32, optional, tag = "4")] pub end: ::core::option::Option, + #[prost(enumeration = "annotation::Semantic", optional, tag = "5")] + pub semantic: ::core::option::Option, + } + /// Nested message and enum types in `Annotation`. + pub mod annotation { + /// Represents the identified object's effect on the element in the original + /// .proto file. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Semantic { + /// There is no effect or the effect is indescribable. + None = 0, + /// The element is set or otherwise mutated. + Set = 1, + /// An alias to the element is returned. + Alias = 2, + } + impl Semantic { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Semantic::None => "NONE", + Semantic::Set => "SET", + Semantic::Alias => "ALIAS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NONE" => Some(Self::None), + "SET" => Some(Self::Set), + "ALIAS" => Some(Self::Alias), + _ => None, + } + } + } } } /// A Timestamp represents a point in time independent of any time zone or local @@ -1327,7 +1923,6 @@ pub mod generated_code_info { /// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) /// .setNanos((int) ((millis % 1000) * 1000000)).build(); /// -/// /// Example 5: Compute Timestamp from Java `Instant.now()`. /// /// Instant now = Instant.now(); @@ -1336,7 +1931,6 @@ pub mod generated_code_info { /// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) /// .setNanos(now.getNano()).build(); /// -/// /// Example 6: Compute Timestamp from current time in Python. /// /// timestamp = Timestamp() @@ -1366,10 +1960,9 @@ pub mod generated_code_info { /// [`strftime`]() with /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use /// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -/// +/// ) /// ) to obtain a formatter capable of generating timestamps in this format. /// -/// #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1445,7 +2038,6 @@ pub struct Timestamp { /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 /// microsecond should be expressed in JSON format as "3.000001s". /// -/// #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Eq)] #[allow(clippy::derive_partial_eq_without_eq)] diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 9e13647a..b6053be0 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -58,6 +58,10 @@ pub struct IdentifiedChannel { /// channel identifier #[prost(string, tag = "7")] pub channel_id: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag = "8")] + pub upgrade_sequence: u64, } /// Counterparty defines a channel end counterparty #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -324,8 +328,9 @@ pub struct PacketSequence { } /// Upgrade is a verifiable type which contains the relevant information /// for an attempted upgrade. It provides the proposed changes to the channel -/// end, the timeout for this upgrade attempt and the latest packet sequence sent -/// to allow the counterparty to block sends after the upgrade has started. +/// end, the timeout for this upgrade attempt and the next packet sequence +/// which allows the counterparty to efficiently know the highest sequence it has received. +/// The next sequence send is used for pruning and upgrading from unordered to ordered channels. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -335,7 +340,7 @@ pub struct Upgrade { #[prost(message, optional, tag = "2")] pub timeout: ::core::option::Option, #[prost(uint64, tag = "3")] - pub latest_sequence_send: u64, + pub next_sequence_send: u64, } /// UpgradeFields are the fields in a channel end which may be changed /// during a channel upgrade. @@ -505,6 +510,8 @@ pub struct MsgChannelCloseConfirm { pub proof_height: ::core::option::Option, #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "6")] + pub counterparty_upgrade_sequence: u64, } /// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response /// type. @@ -575,6 +582,8 @@ pub struct MsgTimeoutOnClose { pub next_sequence_recv: u64, #[prost(string, tag = "6")] pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag = "7")] + pub counterparty_upgrade_sequence: u64, } /// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -627,11 +636,9 @@ pub struct MsgChannelUpgradeInit { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeInitResponse { - #[prost(string, tag = "1")] - pub channel_id: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] + #[prost(message, optional, tag = "1")] pub upgrade: ::core::option::Option, - #[prost(uint64, tag = "3")] + #[prost(uint64, tag = "2")] pub upgrade_sequence: u64, } /// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc @@ -665,13 +672,11 @@ pub struct MsgChannelUpgradeTry { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelUpgradeTryResponse { - #[prost(string, tag = "1")] - pub channel_id: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] + #[prost(message, optional, tag = "1")] pub upgrade: ::core::option::Option, - #[prost(uint64, tag = "3")] + #[prost(uint64, tag = "2")] pub upgrade_sequence: u64, - #[prost(enumeration = "ResponseResultType", tag = "4")] + #[prost(enumeration = "ResponseResultType", tag = "3")] pub result: i32, } /// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc @@ -777,10 +782,7 @@ pub struct MsgChannelUpgradeTimeout { #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeTimeoutResponse { - #[prost(enumeration = "ResponseResultType", tag = "1")] - pub result: i32, -} +pub struct MsgChannelUpgradeTimeoutResponse {} /// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] @@ -823,6 +825,32 @@ pub struct MsgUpdateParams { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUpdateParamsResponse {} +/// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgements { + #[prost(string, tag = "1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub limit: u64, + #[prost(string, tag = "4")] + pub signer: ::prost::alloc::string::String, +} +/// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgementsResponse { + /// Number of sequences pruned (includes both packet acknowledgements and packet receipts where appropriate). + #[prost(uint64, tag = "1")] + pub total_pruned_sequences: u64, + /// Number of sequences left after pruning. + #[prost(uint64, tag = "2")] + pub total_remaining_sequences: u64, +} /// ResponseResultType defines the possible outcomes of the execution of a message #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -1433,6 +1461,34 @@ pub mod msg_client { ); self.inner.unary(req, path, codec).await } + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + pub async fn prune_acknowledgements( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Msg/PruneAcknowledgements", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("ibc.core.channel.v1.Msg", "PruneAcknowledgements"), + ); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -1588,6 +1644,14 @@ pub mod msg_server { tonic::Response, tonic::Status, >; + /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. + async fn prune_acknowledgements( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Msg defines the ibc/channel Msg service. #[derive(Debug)] @@ -2475,6 +2539,52 @@ pub mod msg_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Msg/PruneAcknowledgements" => { + #[allow(non_camel_case_types)] + struct PruneAcknowledgementsSvc(pub Arc); + impl< + T: Msg, + > tonic::server::UnaryService + for PruneAcknowledgementsSvc { + type Response = super::MsgPruneAcknowledgementsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::prune_acknowledgements(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PruneAcknowledgementsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( @@ -3013,6 +3123,20 @@ pub struct QueryUpgradeResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +/// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsRequest {} +/// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. +#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} /// Generated client implementations. #[cfg(feature = "client")] pub mod query_client { @@ -3547,6 +3671,32 @@ pub mod query_client { .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "Upgrade")); self.inner.unary(req, path, codec).await } + /// ChannelParams queries all parameters of the ibc channel submodule. + pub async fn channel_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/ibc.core.channel.v1.Query/ChannelParams", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("ibc.core.channel.v1.Query", "ChannelParams")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -3693,6 +3843,14 @@ pub mod query_server { tonic::Response, tonic::Status, >; + /// ChannelParams queries all parameters of the ibc channel submodule. + async fn channel_params( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } /// Query provides defines the gRPC querier service #[derive(Debug)] @@ -4525,6 +4683,52 @@ pub mod query_server { }; Box::pin(fut) } + "/ibc.core.channel.v1.Query/ChannelParams" => { + #[allow(non_camel_case_types)] + struct ChannelParamsSvc(pub Arc); + impl< + T: Query, + > tonic::server::UnaryService + for ChannelParamsSvc { + type Response = super::QueryChannelParamsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::channel_params(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ChannelParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index bb1bdf04b84fa0804aba2499b430697819814b7f..67a1abe35e79458536cd8533e680298e87afd0ed 100644 GIT binary patch delta 64508 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 Date: Mon, 22 Jan 2024 19:42:11 +0100 Subject: [PATCH 10/15] sync ibc-go with tag 04-channel-upgrades-hermes.integration.1 (#184) --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.applications.fee.v1.rs | 4 ++-- ...tions.interchain_accounts.controller.v1.rs | 5 +++++ src/prost/ibc.applications.transfer.v1.rs | 4 ++++ src/prost/ibc.core.channel.v1.rs | 15 +++++++++++---- src/prost/ibc.core.client.v1.rs | 2 +- src/prost/ibc.core.connection.v1.rs | 6 +++--- src/prost/ibc.lightclients.tendermint.v1.rs | 2 +- src/prost/proto_descriptor.bin | Bin 737265 -> 745710 bytes 9 files changed, 28 insertions(+), 12 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 8c33106a..802233a8 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -7a89e5d5b5ebb7643ce3992c34008c35373ecf34 +4e3d164e4f9a5986bbe6595138feb49160e27215 \ No newline at end of file diff --git a/src/prost/ibc.applications.fee.v1.rs b/src/prost/ibc.applications.fee.v1.rs index 0a0885f6..ac68851b 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -107,7 +107,7 @@ pub struct MsgPayPacketFee { /// the source port unique identifier #[prost(string, tag = "2")] pub source_port_id: ::prost::alloc::string::String, - /// the source channel unique identifer + /// the source channel unique identifier #[prost(string, tag = "3")] pub source_channel_id: ::prost::alloc::string::String, /// account address to refund fee if necessary @@ -791,7 +791,7 @@ pub struct ForwardRelayerAddress { /// the forward relayer address #[prost(string, tag = "1")] pub address: ::prost::alloc::string::String, - /// unique packet identifer comprised of the channel ID, port ID and sequence + /// unique packet identifier comprised of the channel ID, port ID and sequence #[prost(message, optional, tag = "2")] pub packet_id: ::core::option::Option< super::super::super::core::channel::v1::PacketId, diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index a351adda..f9f95bbc 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs @@ -19,6 +19,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 order: i32, } /// MsgRegisterInterchainAccountResponse defines the response for Msg/RegisterAccount #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] diff --git a/src/prost/ibc.applications.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index ba523ebd..1d5e32ad 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -1328,6 +1328,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>, } /// TransferAuthorization allows the grantee to spend up to spend_limit coins from /// the granter's account for ibc transfer on a specific channel diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index b6053be0..bbdca680 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -132,7 +132,7 @@ pub struct PacketState { #[prost(bytes = "vec", tag = "4")] pub data: ::prost::alloc::vec::Vec, } -/// PacketId is an identifer for a unique Packet +/// PacketId is an identifier for a unique Packet /// Source chains refer to packets by source port/channel /// Destination chains refer to packets by destination port/channel #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] @@ -429,6 +429,9 @@ pub struct 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. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -618,6 +621,8 @@ pub struct MsgAcknowledgementResponse { pub result: i32, } /// 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. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -748,11 +753,13 @@ pub struct MsgChannelUpgradeOpen { pub channel_id: ::prost::alloc::string::String, #[prost(enumeration = "State", tag = "3")] pub counterparty_channel_state: i32, - #[prost(bytes = "vec", tag = "4")] + #[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 = "5")] + #[prost(message, optional, tag = "6")] pub proof_height: ::core::option::Option, - #[prost(string, tag = "6")] + #[prost(string, tag = "7")] pub signer: ::prost::alloc::string::String, } /// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index 05dd3b4b..201c5e30 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -1199,7 +1199,7 @@ pub struct QueryConsensusStateRequest { /// consensus state revision height #[prost(uint64, tag = "3")] pub revision_height: u64, - /// latest_height overrrides the height field and queries the latest stored + /// latest_height overrides the height field and queries the latest stored /// ConsensusState #[prost(bool, tag = "4")] pub latest_height: bool, diff --git a/src/prost/ibc.core.connection.v1.rs b/src/prost/ibc.core.connection.v1.rs index 12cc3618..2c4ac346 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -97,7 +97,7 @@ pub struct ConnectionPaths { #[prost(string, repeated, tag = "2")] pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } -/// Version defines the versioning scheme used to negotiate the IBC verison in +/// Version defines the versioning scheme used to negotiate the IBC version in /// the connection handshake. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[cfg_attr( @@ -227,7 +227,7 @@ pub struct MsgConnectionOpenTry { pub counterparty_versions: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "7")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain A: `UNITIALIZED -> + /// proof of the initialization the connection on Chain A: `UNINITIALIZED -> /// INIT` #[prost(bytes = "vec", tag = "8")] pub proof_init: ::prost::alloc::vec::Vec, @@ -268,7 +268,7 @@ pub struct MsgConnectionOpenAck { >, #[prost(message, optional, tag = "5")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain B: `UNITIALIZED -> + /// proof of the initialization the connection on Chain B: `UNINITIALIZED -> /// TRYOPEN` #[prost(bytes = "vec", tag = "6")] pub proof_try: ::prost::alloc::vec::Vec, diff --git a/src/prost/ibc.lightclients.tendermint.v1.rs b/src/prost/ibc.lightclients.tendermint.v1.rs index 8849c261..6413016b 100644 --- a/src/prost/ibc.lightclients.tendermint.v1.rs +++ b/src/prost/ibc.lightclients.tendermint.v1.rs @@ -8,7 +8,7 @@ pub struct ClientState { pub chain_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "2")] pub trust_level: ::core::option::Option, - /// duration of the period since the LastestTimestamp during which the + /// duration of the period since the LatestTimestamp during which the /// submitted headers are valid for upgrade #[prost(message, optional, tag = "3")] pub trusting_period: ::core::option::Option< diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index 67a1abe35e79458536cd8533e680298e87afd0ed..29e7d2b2e10921d2531fe222099fc2bb5a0a5c07 100644 GIT binary patch delta 18446 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 Date: Wed, 24 Jan 2024 11:09:39 +0100 Subject: [PATCH 11/15] Sync ibc-go with v8.1.0-rc.0 (#185) --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.applications.fee.v1.rs | 4 ++-- ...tions.interchain_accounts.controller.v1.rs | 2 +- src/prost/ibc.core.channel.v1.rs | 2 +- src/prost/ibc.core.client.v1.rs | 2 +- src/prost/ibc.core.connection.v1.rs | 6 +++--- src/prost/ibc.lightclients.tendermint.v1.rs | 2 +- src/prost/proto_descriptor.bin | Bin 745710 -> 738122 bytes 8 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 802233a8..2ef27d74 100644 --- a/src/IBC_GO_COMMIT +++ b/src/IBC_GO_COMMIT @@ -1 +1 @@ -4e3d164e4f9a5986bbe6595138feb49160e27215 \ No newline at end of file +e638546626361e83cdb75a5307e929fea551d36a \ No newline at end of file diff --git a/src/prost/ibc.applications.fee.v1.rs b/src/prost/ibc.applications.fee.v1.rs index ac68851b..0a0885f6 100644 --- a/src/prost/ibc.applications.fee.v1.rs +++ b/src/prost/ibc.applications.fee.v1.rs @@ -107,7 +107,7 @@ pub struct MsgPayPacketFee { /// the source port unique identifier #[prost(string, tag = "2")] pub source_port_id: ::prost::alloc::string::String, - /// the source channel unique identifier + /// the source channel unique identifer #[prost(string, tag = "3")] pub source_channel_id: ::prost::alloc::string::String, /// account address to refund fee if necessary @@ -791,7 +791,7 @@ pub struct ForwardRelayerAddress { /// the forward relayer address #[prost(string, tag = "1")] pub address: ::prost::alloc::string::String, - /// unique packet identifier comprised of the channel ID, port ID and sequence + /// unique packet identifer comprised of the channel ID, port ID and sequence #[prost(message, optional, tag = "2")] pub packet_id: ::core::option::Option< super::super::super::core::channel::v1::PacketId, diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index f9f95bbc..902c155c 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs @@ -23,7 +23,7 @@ pub struct MsgRegisterInterchainAccount { enumeration = "super::super::super::super::core::channel::v1::Order", tag = "4" )] - pub order: i32, + pub ordering: i32, } /// MsgRegisterInterchainAccountResponse defines the response for Msg/RegisterAccount #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index bbdca680..00fcec5f 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -132,7 +132,7 @@ pub struct PacketState { #[prost(bytes = "vec", tag = "4")] pub data: ::prost::alloc::vec::Vec, } -/// PacketId is an identifier for a unique Packet +/// PacketId is an identifer for a unique Packet /// Source chains refer to packets by source port/channel /// Destination chains refer to packets by destination port/channel #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] diff --git a/src/prost/ibc.core.client.v1.rs b/src/prost/ibc.core.client.v1.rs index 201c5e30..05dd3b4b 100644 --- a/src/prost/ibc.core.client.v1.rs +++ b/src/prost/ibc.core.client.v1.rs @@ -1199,7 +1199,7 @@ pub struct QueryConsensusStateRequest { /// consensus state revision height #[prost(uint64, tag = "3")] pub revision_height: u64, - /// latest_height overrides the height field and queries the latest stored + /// latest_height overrrides the height field and queries the latest stored /// ConsensusState #[prost(bool, tag = "4")] pub latest_height: bool, diff --git a/src/prost/ibc.core.connection.v1.rs b/src/prost/ibc.core.connection.v1.rs index 2c4ac346..12cc3618 100644 --- a/src/prost/ibc.core.connection.v1.rs +++ b/src/prost/ibc.core.connection.v1.rs @@ -97,7 +97,7 @@ pub struct ConnectionPaths { #[prost(string, repeated, tag = "2")] pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } -/// Version defines the versioning scheme used to negotiate the IBC version in +/// Version defines the versioning scheme used to negotiate the IBC verison in /// the connection handshake. #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[cfg_attr( @@ -227,7 +227,7 @@ pub struct MsgConnectionOpenTry { pub counterparty_versions: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "7")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain A: `UNINITIALIZED -> + /// proof of the initialization the connection on Chain A: `UNITIALIZED -> /// INIT` #[prost(bytes = "vec", tag = "8")] pub proof_init: ::prost::alloc::vec::Vec, @@ -268,7 +268,7 @@ pub struct MsgConnectionOpenAck { >, #[prost(message, optional, tag = "5")] pub proof_height: ::core::option::Option, - /// proof of the initialization the connection on Chain B: `UNINITIALIZED -> + /// proof of the initialization the connection on Chain B: `UNITIALIZED -> /// TRYOPEN` #[prost(bytes = "vec", tag = "6")] pub proof_try: ::prost::alloc::vec::Vec, diff --git a/src/prost/ibc.lightclients.tendermint.v1.rs b/src/prost/ibc.lightclients.tendermint.v1.rs index 6413016b..8849c261 100644 --- a/src/prost/ibc.lightclients.tendermint.v1.rs +++ b/src/prost/ibc.lightclients.tendermint.v1.rs @@ -8,7 +8,7 @@ pub struct ClientState { pub chain_id: ::prost::alloc::string::String, #[prost(message, optional, tag = "2")] pub trust_level: ::core::option::Option, - /// duration of the period since the LatestTimestamp during which the + /// duration of the period since the LastestTimestamp during which the /// submitted headers are valid for upgrade #[prost(message, optional, tag = "3")] pub trusting_period: ::core::option::Option< diff --git a/src/prost/proto_descriptor.bin b/src/prost/proto_descriptor.bin index 29e7d2b2e10921d2531fe222099fc2bb5a0a5c07..c8fb406ecc5c0e7a7fc2bfbe4e552a9447c102be 100644 GIT binary patch delta 492 zcmXAjQAkr^6vyv5-?_WDPj-b{ZR;}FRc4ALNTCmF1O+{4!^R-V2yC<|Bbu@8CF{W` z9O`^9AHK>+>|xMjQ5>i+dI^fsy*P}}AnL^+f_fO6G@-v>LMfJD-5-%ZdK0Gukg$@KXP*-~G| z%@y5r-pysQ`BH9#X9_sz(CeczqFM$p$bTwWZfaWWl!mQq+8nehh~p7{dkagZbygA~ z8n!r&LFc3zSi(40mhdiF!(KwD+aiqtC$*FG=*MF2xl`pr6}eCq58B~AhgZa6GyLY~ z8)CoT8fiGf7MF0JGo-$6i9Ia7inyOY@1@Zz@PiX`^wEGBK5(0!f;H~lYlyZ8Vcxl@ ze%_%d6gjj&Ls9zMBVFa+q!7=(pt?_9?~p#5H0^Tx&i}i4;uR&Et%Hq4uOW>Qr%i3H zQ7c289vQUl$hQCf>IPjU_`r!z6f>>U4FhZu!-R7}JzS@N8e66qf7v2&k1DP_tgcP! zhd45&OQ2^U!)j$#539auebC=4&9OozTgc@{L!?^Pv6E}l`mhPna`(LM;qx#&OpjgM JJujEv{R6X;lH33Q delta 6500 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 B4#fZf From d2643979a0f88a774602645567c0074fb13dc4c4 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 13:56:35 +0100 Subject: [PATCH 12/15] Fix channel protos --- src/prost/ibc.core.channel.v1.rs | 1843 +++++++----------------------- src/prost/proto_descriptor.bin | Bin 738122 -> 740247 bytes 2 files changed, 419 insertions(+), 1424 deletions(-) diff --git a/src/prost/ibc.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index 00fcec5f..b354e656 100644 --- a/src/prost/ibc.core.channel.v1.rs +++ b/src/prost/ibc.core.channel.v1.rs @@ -1,7 +1,6 @@ /// Channel defines pipeline for exactly-once packet delivery between specific /// modules on separate blockchains, which has at least one end capable of /// sending packets and one end capable of receiving packets. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[cfg_attr( all(feature = "json-schema", feature = "serde"), derive(::schemars::JsonSchema) @@ -25,14 +24,16 @@ 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"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// IdentifiedChannel defines a channel with additional port and channel /// identifier fields. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct IdentifiedChannel { @@ -58,13 +59,15 @@ 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"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// Counterparty defines a channel end counterparty -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[cfg_attr( all(feature = "json-schema", feature = "serde"), derive(::schemars::JsonSchema) @@ -79,8 +82,14 @@ pub struct Counterparty { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } +impl ::prost::Name for Counterparty { + const NAME: &'static str = "Counterparty"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// Packet defines a type that carries data across different chains through IBC -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Packet { @@ -111,11 +120,17 @@ pub struct Packet { #[prost(uint64, tag = "8")] pub timeout_timestamp: u64, } +impl ::prost::Name for Packet { + const NAME: &'static str = "Packet"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// PacketState defines the generic type necessary to retrieve and store /// packet commitments, acknowledgements, and receipts. /// Caller is responsible for knowing the context necessary to interpret this /// state as a commitment, acknowledgement, or a receipt. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketState { @@ -132,10 +147,16 @@ pub struct PacketState { #[prost(bytes = "vec", tag = "4")] pub data: ::prost::alloc::vec::Vec, } +impl ::prost::Name for PacketState { + const NAME: &'static str = "PacketState"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// PacketId is an identifer for a unique Packet /// Source chains refer to packets by source port/channel /// Destination chains refer to packets by destination port/channel -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketId { @@ -149,6 +170,13 @@ pub struct PacketId { #[prost(uint64, tag = "3")] pub sequence: u64, } +impl ::prost::Name for PacketId { + const NAME: &'static str = "PacketId"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// Acknowledgement is the recommended acknowledgement format to be used by /// app-specific protocols. /// NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental @@ -156,7 +184,6 @@ pub struct PacketId { /// The first byte of any message with this format will be the non-ASCII values /// `0xaa` (result) or `0xb2` (error). Implemented as defined by ICS: /// -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Acknowledgement { @@ -167,7 +194,6 @@ pub struct Acknowledgement { /// Nested message and enum types in `Acknowledgement`. pub mod acknowledgement { /// response contains either a result or an error and must be non-empty - #[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Response { @@ -177,10 +203,16 @@ pub mod acknowledgement { Error(::prost::alloc::string::String), } } +impl ::prost::Name for Acknowledgement { + const NAME: &'static str = "Acknowledgement"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// Timeout defines an execution deadline structure for 04-channel handlers. /// This includes packet lifecycle handlers as well as the upgrade handshake handlers. /// A valid Timeout contains either one or both of a timestamp and block height (sequence). -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Timeout { @@ -191,18 +223,15 @@ pub struct Timeout { #[prost(uint64, tag = "2")] pub timestamp: u64, } -/// Params defines the set of IBC channel parameters. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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 Timeout { + const NAME: &'static str = "Timeout"; + 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, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] +/// CLOSED, INIT, TRYOPEN, OPEN or UNINITIALIZED. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { @@ -218,10 +247,6 @@ 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. @@ -235,8 +260,6 @@ 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. @@ -247,14 +270,11 @@ 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, } } } /// Order defines if a channel is ORDERED or UNORDERED -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Order { @@ -289,7 +309,6 @@ impl Order { } } /// GenesisState defines the ibc channel submodule's genesis state. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenesisState { @@ -310,12 +329,16 @@ 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"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// PacketSequence defines the genesis type necessary to retrieve and store /// next send and receive sequences. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct PacketSequence { @@ -326,52 +349,15 @@ pub struct PacketSequence { #[prost(uint64, tag = "3")] pub sequence: u64, } -/// 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. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// UpgradeFields are the fields in a channel end which may be changed -/// during a channel upgrade. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// 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. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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 PacketSequence { + const NAME: &'static str = "PacketSequence"; + 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. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenInit { @@ -382,8 +368,14 @@ pub struct MsgChannelOpenInit { #[prost(string, tag = "3")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenInit { + const NAME: &'static str = "MsgChannelOpenInit"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenInitResponse { @@ -392,10 +384,16 @@ pub struct MsgChannelOpenInitResponse { #[prost(string, tag = "2")] pub version: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenInitResponse { + const NAME: &'static str = "MsgChannelOpenInitResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel /// on Chain B. The version field within the Channel field has been deprecated. Its /// value will be ignored by core IBC. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenTry { @@ -417,8 +415,14 @@ pub struct MsgChannelOpenTry { #[prost(string, tag = "7")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenTry { + const NAME: &'static str = "MsgChannelOpenTry"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenTryResponse { @@ -427,12 +431,15 @@ pub struct MsgChannelOpenTryResponse { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenTryResponse { + const NAME: &'static str = "MsgChannelOpenTryResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// 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. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenAck { @@ -451,14 +458,26 @@ pub struct MsgChannelOpenAck { #[prost(string, tag = "7")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenAck { + const NAME: &'static str = "MsgChannelOpenAck"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenAckResponse {} +impl ::prost::Name for MsgChannelOpenAckResponse { + const NAME: &'static str = "MsgChannelOpenAckResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to /// acknowledge the change of channel state to OPEN on Chain A. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenConfirm { @@ -473,15 +492,27 @@ pub struct MsgChannelOpenConfirm { #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelOpenConfirm { + const NAME: &'static str = "MsgChannelOpenConfirm"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response /// type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelOpenConfirmResponse {} +impl ::prost::Name for MsgChannelOpenConfirmResponse { + const NAME: &'static str = "MsgChannelOpenConfirmResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A /// to close a channel with Chain B. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseInit { @@ -492,14 +523,26 @@ pub struct MsgChannelCloseInit { #[prost(string, tag = "3")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgChannelCloseInit { + const NAME: &'static str = "MsgChannelCloseInit"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseInitResponse {} +impl ::prost::Name for MsgChannelCloseInitResponse { + const NAME: &'static str = "MsgChannelCloseInitResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B /// to acknowledge the change of channel state to CLOSED on Chain A. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseConfirm { @@ -513,17 +556,27 @@ 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"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response /// type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgChannelCloseConfirmResponse {} +impl ::prost::Name for MsgChannelCloseConfirmResponse { + const NAME: &'static str = "MsgChannelCloseConfirmResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgRecvPacket receives incoming IBC packet -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgRecvPacket { @@ -536,16 +589,28 @@ pub struct MsgRecvPacket { #[prost(string, tag = "4")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgRecvPacket { + const NAME: &'static str = "MsgRecvPacket"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgRecvPacketResponse defines the Msg/RecvPacket response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgRecvPacketResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } +impl ::prost::Name for MsgRecvPacketResponse { + const NAME: &'static str = "MsgRecvPacketResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgTimeout receives timed-out packet -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeout { @@ -560,16 +625,28 @@ pub struct MsgTimeout { #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgTimeout { + const NAME: &'static str = "MsgTimeout"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgTimeoutResponse defines the Msg/Timeout response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } +impl ::prost::Name for MsgTimeoutResponse { + const NAME: &'static str = "MsgTimeoutResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgTimeoutOnClose timed-out packet upon counterparty channel closure. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutOnClose { @@ -585,19 +662,29 @@ 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"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgTimeoutOnCloseResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } +impl ::prost::Name for MsgTimeoutOnCloseResponse { + const NAME: &'static str = "MsgTimeoutOnCloseResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgAcknowledgement receives incoming IBC acknowledgement -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgAcknowledgement { @@ -612,254 +699,28 @@ pub struct MsgAcknowledgement { #[prost(string, tag = "5")] pub signer: ::prost::alloc::string::String, } +impl ::prost::Name for MsgAcknowledgement { + const NAME: &'static str = "MsgAcknowledgement"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgAcknowledgementResponse { #[prost(enumeration = "ResponseResultType", tag = "1")] pub result: i32, } -/// 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. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeAckResponse { - #[prost(enumeration = "ResponseResultType", tag = "1")] - pub result: i32, -} -/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeConfirmResponse { - #[prost(enumeration = "ResponseResultType", tag = "1")] - pub result: i32, -} -/// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeOpenResponse {} -/// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgChannelUpgradeTimeoutRepsonse defines the MsgChannelUpgradeTimeout response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeTimeoutResponse {} -/// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[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, -} -/// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgChannelUpgradeCancelResponse {} -/// MsgUpdateParams is the MsgUpdateParams request type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[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, -} -/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgUpdateParamsResponse {} -/// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgPruneAcknowledgements { - #[prost(string, tag = "1")] - pub port_id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub channel_id: ::prost::alloc::string::String, - #[prost(uint64, tag = "3")] - pub limit: u64, - #[prost(string, tag = "4")] - pub signer: ::prost::alloc::string::String, -} -/// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgPruneAcknowledgementsResponse { - /// Number of sequences pruned (includes both packet acknowledgements and packet receipts where appropriate). - #[prost(uint64, tag = "1")] - pub total_pruned_sequences: u64, - /// Number of sequences left after pruning. - #[prost(uint64, tag = "2")] - pub total_remaining_sequences: u64, +impl ::prost::Name for MsgAcknowledgementResponse { + const NAME: &'static str = "MsgAcknowledgementResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } } /// ResponseResultType defines the possible outcomes of the execution of a message -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ResponseResultType { @@ -869,8 +730,6 @@ pub enum ResponseResultType { 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. @@ -882,7 +741,6 @@ impl ResponseResultType { 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. @@ -891,7 +749,6 @@ impl ResponseResultType { "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, } } @@ -1248,270 +1105,22 @@ 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, + } +} +/// 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 { + /// ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. + async fn channel_open_init( + &self, + request: tonic::Request, ) -> 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. -#[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 { - /// ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. - async fn channel_open_init( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; /// ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry. @@ -1587,78 +1196,6 @@ pub mod msg_server { 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::Status, - >; - /// ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout. - async fn channel_upgrade_timeout( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel. - async fn channel_upgrade_cancel( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// UpdateChannelParams defines a rpc handler method for MsgUpdateParams. - async fn update_channel_params( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements. - async fn prune_acknowledgements( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; } /// Msg defines the ibc/channel Msg service. #[derive(Debug)] @@ -2184,414 +1721,6 @@ pub mod msg_server { }; 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 ChannelUpgradeInitSvc { - type Response = super::MsgChannelUpgradeInitResponse; - 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_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 = ChannelUpgradeInitSvc(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/ChannelUpgradeTry" => { - #[allow(non_camel_case_types)] - 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, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::channel_upgrade_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 = ChannelUpgradeTrySvc(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/ChannelUpgradeAck" => { - #[allow(non_camel_case_types)] - 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 ChannelUpgradeConfirmSvc { - type Response = super::MsgChannelUpgradeConfirmResponse; - 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_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 = ChannelUpgradeConfirmSvc(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/ChannelUpgradeOpen" => { - #[allow(non_camel_case_types)] - 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, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::channel_upgrade_open(&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 = ChannelUpgradeOpenSvc(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/ChannelUpgradeTimeout" => { - #[allow(non_camel_case_types)] - 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, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::channel_upgrade_timeout(&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 = ChannelUpgradeTimeoutSvc(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/ChannelUpgradeCancel" => { - #[allow(non_camel_case_types)] - 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, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::channel_upgrade_cancel(&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 = ChannelUpgradeCancelSvc(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/UpdateChannelParams" => { - #[allow(non_camel_case_types)] - 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, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - ::update_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 = 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( - 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( @@ -2634,7 +1763,6 @@ pub mod msg_server { } } /// QueryChannelRequest is the request type for the Query/Channel RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelRequest { @@ -2645,10 +1773,16 @@ pub struct QueryChannelRequest { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } +impl ::prost::Name for QueryChannelRequest { + const NAME: &'static str = "QueryChannelRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelResponse is the response type for the Query/Channel RPC method. /// Besides the Channel end, it includes a proof and the height from which the /// proof was retrieved. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelResponse { @@ -2662,8 +1796,14 @@ pub struct QueryChannelResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryChannelResponse { + const NAME: &'static str = "QueryChannelResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelsRequest is the request type for the Query/Channels RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelsRequest { @@ -2673,8 +1813,14 @@ pub struct QueryChannelsRequest { super::super::super::super::cosmos::base::query::v1beta1::PageRequest, >, } +impl ::prost::Name for QueryChannelsRequest { + const NAME: &'static str = "QueryChannelsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelsResponse is the response type for the Query/Channels RPC method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelsResponse { @@ -2690,9 +1836,15 @@ pub struct QueryChannelsResponse { #[prost(message, optional, tag = "3")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryChannelsResponse { + const NAME: &'static str = "QueryChannelsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryConnectionChannelsRequest is the request type for the /// Query/QueryConnectionChannels RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryConnectionChannelsRequest { @@ -2705,9 +1857,15 @@ pub struct QueryConnectionChannelsRequest { super::super::super::super::cosmos::base::query::v1beta1::PageRequest, >, } +impl ::prost::Name for QueryConnectionChannelsRequest { + const NAME: &'static str = "QueryConnectionChannelsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryConnectionChannelsResponse is the Response type for the /// Query/QueryConnectionChannels RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryConnectionChannelsResponse { @@ -2723,9 +1881,15 @@ pub struct QueryConnectionChannelsResponse { #[prost(message, optional, tag = "3")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryConnectionChannelsResponse { + const NAME: &'static str = "QueryConnectionChannelsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelClientStateRequest is the request type for the Query/ClientState /// RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelClientStateRequest { @@ -2736,9 +1900,15 @@ pub struct QueryChannelClientStateRequest { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } +impl ::prost::Name for QueryChannelClientStateRequest { + const NAME: &'static str = "QueryChannelClientStateRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelClientStateResponse is the Response type for the /// Query/QueryChannelClientState RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelClientStateResponse { @@ -2754,9 +1924,15 @@ pub struct QueryChannelClientStateResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryChannelClientStateResponse { + const NAME: &'static str = "QueryChannelClientStateResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelConsensusStateRequest is the request type for the /// Query/ConsensusState RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelConsensusStateRequest { @@ -2773,9 +1949,15 @@ pub struct QueryChannelConsensusStateRequest { #[prost(uint64, tag = "4")] pub revision_height: u64, } +impl ::prost::Name for QueryChannelConsensusStateRequest { + const NAME: &'static str = "QueryChannelConsensusStateRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryChannelClientStateResponse is the Response type for the /// Query/QueryChannelClientState RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryChannelConsensusStateResponse { @@ -2794,9 +1976,15 @@ pub struct QueryChannelConsensusStateResponse { #[prost(message, optional, tag = "4")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryChannelConsensusStateResponse { + const NAME: &'static str = "QueryChannelConsensusStateResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketCommitmentRequest is the request type for the /// Query/PacketCommitment RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentRequest { @@ -2810,10 +1998,16 @@ pub struct QueryPacketCommitmentRequest { #[prost(uint64, tag = "3")] pub sequence: u64, } +impl ::prost::Name for QueryPacketCommitmentRequest { + const NAME: &'static str = "QueryPacketCommitmentRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketCommitmentResponse defines the client query response for a packet /// which also includes a proof and the height from which the proof was /// retrieved -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentResponse { @@ -2827,9 +2021,15 @@ pub struct QueryPacketCommitmentResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryPacketCommitmentResponse { + const NAME: &'static str = "QueryPacketCommitmentResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketCommitmentsRequest is the request type for the /// Query/QueryPacketCommitments RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentsRequest { @@ -2845,9 +2045,15 @@ pub struct QueryPacketCommitmentsRequest { super::super::super::super::cosmos::base::query::v1beta1::PageRequest, >, } +impl ::prost::Name for QueryPacketCommitmentsRequest { + const NAME: &'static str = "QueryPacketCommitmentsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketCommitmentsResponse is the request type for the /// Query/QueryPacketCommitments RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketCommitmentsResponse { @@ -2862,9 +2068,15 @@ pub struct QueryPacketCommitmentsResponse { #[prost(message, optional, tag = "3")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryPacketCommitmentsResponse { + const NAME: &'static str = "QueryPacketCommitmentsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketReceiptRequest is the request type for the /// Query/PacketReceipt RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketReceiptRequest { @@ -2878,10 +2090,16 @@ pub struct QueryPacketReceiptRequest { #[prost(uint64, tag = "3")] pub sequence: u64, } +impl ::prost::Name for QueryPacketReceiptRequest { + const NAME: &'static str = "QueryPacketReceiptRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketReceiptResponse defines the client query response for a packet /// receipt which also includes a proof, and the height from which the proof was /// retrieved -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketReceiptResponse { @@ -2895,9 +2113,15 @@ pub struct QueryPacketReceiptResponse { #[prost(message, optional, tag = "4")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryPacketReceiptResponse { + const NAME: &'static str = "QueryPacketReceiptResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketAcknowledgementRequest is the request type for the /// Query/PacketAcknowledgement RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementRequest { @@ -2911,10 +2135,16 @@ pub struct QueryPacketAcknowledgementRequest { #[prost(uint64, tag = "3")] pub sequence: u64, } +impl ::prost::Name for QueryPacketAcknowledgementRequest { + const NAME: &'static str = "QueryPacketAcknowledgementRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketAcknowledgementResponse defines the client query response for a /// packet which also includes a proof and the height from which the /// proof was retrieved -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementResponse { @@ -2928,9 +2158,15 @@ pub struct QueryPacketAcknowledgementResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryPacketAcknowledgementResponse { + const NAME: &'static str = "QueryPacketAcknowledgementResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketAcknowledgementsRequest is the request type for the /// Query/QueryPacketCommitments RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementsRequest { @@ -2949,9 +2185,15 @@ pub struct QueryPacketAcknowledgementsRequest { #[prost(uint64, repeated, tag = "4")] pub packet_commitment_sequences: ::prost::alloc::vec::Vec, } +impl ::prost::Name for QueryPacketAcknowledgementsRequest { + const NAME: &'static str = "QueryPacketAcknowledgementsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryPacketAcknowledgemetsResponse is the request type for the /// Query/QueryPacketAcknowledgements RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPacketAcknowledgementsResponse { @@ -2966,9 +2208,15 @@ pub struct QueryPacketAcknowledgementsResponse { #[prost(message, optional, tag = "3")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryPacketAcknowledgementsResponse { + const NAME: &'static str = "QueryPacketAcknowledgementsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryUnreceivedPacketsRequest is the request type for the /// Query/UnreceivedPackets RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedPacketsRequest { @@ -2982,9 +2230,15 @@ pub struct QueryUnreceivedPacketsRequest { #[prost(uint64, repeated, tag = "3")] pub packet_commitment_sequences: ::prost::alloc::vec::Vec, } +impl ::prost::Name for QueryUnreceivedPacketsRequest { + const NAME: &'static str = "QueryUnreceivedPacketsRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryUnreceivedPacketsResponse is the response type for the /// Query/UnreceivedPacketCommitments RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedPacketsResponse { @@ -2995,9 +2249,15 @@ pub struct QueryUnreceivedPacketsResponse { #[prost(message, optional, tag = "2")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryUnreceivedPacketsResponse { + const NAME: &'static str = "QueryUnreceivedPacketsResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryUnreceivedAcks is the request type for the /// Query/UnreceivedAcks RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedAcksRequest { @@ -3011,9 +2271,15 @@ pub struct QueryUnreceivedAcksRequest { #[prost(uint64, repeated, tag = "3")] pub packet_ack_sequences: ::prost::alloc::vec::Vec, } +impl ::prost::Name for QueryUnreceivedAcksRequest { + const NAME: &'static str = "QueryUnreceivedAcksRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryUnreceivedAcksResponse is the response type for the /// Query/UnreceivedAcks RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnreceivedAcksResponse { @@ -3024,9 +2290,15 @@ pub struct QueryUnreceivedAcksResponse { #[prost(message, optional, tag = "2")] pub height: ::core::option::Option, } +impl ::prost::Name for QueryUnreceivedAcksResponse { + const NAME: &'static str = "QueryUnreceivedAcksResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryNextSequenceReceiveRequest is the request type for the /// Query/QueryNextSequenceReceiveRequest RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceReceiveRequest { @@ -3037,9 +2309,15 @@ pub struct QueryNextSequenceReceiveRequest { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } -/// QuerySequenceResponse is the response type for the +impl ::prost::Name for QueryNextSequenceReceiveRequest { + const NAME: &'static str = "QueryNextSequenceReceiveRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} +/// QuerySequenceResponse is the request type for the /// Query/QueryNextSequenceReceiveResponse RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceReceiveResponse { @@ -3053,9 +2331,15 @@ pub struct QueryNextSequenceReceiveResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } +impl ::prost::Name for QueryNextSequenceReceiveResponse { + const NAME: &'static str = "QueryNextSequenceReceiveResponse"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryNextSequenceSendRequest is the request type for the /// Query/QueryNextSequenceSend RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceSendRequest { @@ -3066,9 +2350,15 @@ pub struct QueryNextSequenceSendRequest { #[prost(string, tag = "2")] pub channel_id: ::prost::alloc::string::String, } +impl ::prost::Name for QueryNextSequenceSendRequest { + const NAME: &'static str = "QueryNextSequenceSendRequest"; + const PACKAGE: &'static str = "ibc.core.channel.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("ibc.core.channel.v1.{}", Self::NAME) + } +} /// QueryNextSequenceSendResponse is the request type for the /// Query/QueryNextSequenceSend RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryNextSequenceSendResponse { @@ -3082,67 +2372,12 @@ pub struct QueryNextSequenceSendResponse { #[prost(message, optional, tag = "3")] pub proof_height: ::core::option::Option, } -/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeErrorRequest { - #[prost(string, tag = "1")] - pub port_id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub channel_id: ::prost::alloc::string::String, -} -/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct 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, -} -/// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryUpgradeRequest { - #[prost(string, tag = "1")] - pub port_id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub channel_id: ::prost::alloc::string::String, -} -/// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct 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, -} -/// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryChannelParamsRequest {} -/// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. -#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryChannelParamsResponse { - /// params defines the parameters of the module. - #[prost(message, optional, tag = "1")] - pub params: ::core::option::Option, +impl ::prost::Name for QueryNextSequenceSendResponse { + const NAME: &'static str = "QueryNextSequenceSendResponse"; + 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")] @@ -3626,84 +2861,6 @@ 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. @@ -3834,30 +2991,6 @@ 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)] @@ -4598,144 +3731,6 @@ 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/proto_descriptor.bin b/src/prost/proto_descriptor.bin index c8fb406ecc5c0e7a7fc2bfbe4e552a9447c102be..ae805c553896cdb51d5db0025c7069d1c406032c 100644 GIT binary patch delta 54026 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 U0*ZW4LX!bSK2#Dd1WM%de;eRl82|tP delta 54073 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

aG&6cJF1DK>lnFI)umU#P4GG$3l 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 From c380c9c57fccc6027727c11564ab54c1b81cf125 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 13:58:30 +0100 Subject: [PATCH 13/15] Add changes related to v8.1.0 --- src/prost/google.protobuf.rs | 4 ++-- .../ibc.applications.interchain_accounts.controller.v1.rs | 5 ----- src/prost/ibc.applications.transfer.v1.rs | 4 ---- 3 files changed, 2 insertions(+), 11 deletions(-) diff --git a/src/prost/google.protobuf.rs b/src/prost/google.protobuf.rs index 5182a342..5976a8b1 100644 --- a/src/prost/google.protobuf.rs +++ b/src/prost/google.protobuf.rs @@ -27,7 +27,7 @@ /// foo = any.unpack(Foo.getDefaultInstance()); /// } /// -/// Example 3: Pack and unpack a message in Python. +/// Example 3: Pack and unpack a message in Python. /// /// foo = Foo(...) /// any = Any() @@ -37,7 +37,7 @@ /// any.Unpack(foo) /// ... /// -/// Example 4: Pack and unpack a message in Go +/// Example 4: Pack and unpack a message in Go /// /// foo := &pb.Foo{...} /// any, err := anypb.New(foo) diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index 81fe9836..00e306a3 100644 --- a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs +++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs @@ -26,11 +26,6 @@ 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.transfer.v1.rs b/src/prost/ibc.applications.transfer.v1.rs index 70c3a6c7..0c84ba34 100644 --- a/src/prost/ibc.applications.transfer.v1.rs +++ b/src/prost/ibc.applications.transfer.v1.rs @@ -1434,10 +1434,6 @@ 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"; From 6642cfb904c3e0013d4f178b662793ce5a30651b Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 14:03:58 +0100 Subject: [PATCH 14/15] Add only channel upgrade changes --- src/IBC_GO_COMMIT | 2 +- src/prost/ibc.core.channel.v1.rs | 2043 +++++++- src/prost/ibc.core.channel.v1.serde.rs | 6238 +++++++++++++++++++----- src/prost/proto_descriptor.bin | Bin 740247 -> 753876 bytes 4 files changed, 6744 insertions(+), 1539 deletions(-) diff --git a/src/IBC_GO_COMMIT b/src/IBC_GO_COMMIT index 5a5a9e99..19b35bf5 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.core.channel.v1.rs b/src/prost/ibc.core.channel.v1.rs index b354e656..53c79e71 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 1bf7c67b..abb6af8a 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/proto_descriptor.bin b/src/prost/proto_descriptor.bin index ae805c553896cdb51d5db0025c7069d1c406032c..ae83dea17b9bc744dd5e4878e7e225ebb1fa2656 100644 GIT binary patch delta 34173 zcmb__cYKva_V;~e?!CEr(x3F3n{X3CNgyE*iu8{3KnNg+KnNFzKoV0#EPE*yELc`y z?4oPI!XlQ9brpNrWkKC{?d|8fx{8XruIuhk-|w07JOSeFe%{af2Ym9KnRDjMIcLf< zb7rm(6|Zfs+;pz>0Q+$%`{SIQ%UFx`K<8=8nBS^)%Ix%xmesBGD`U&rVyAV)ni^tx z!Kl^OUz?`W=jr4T{%yN@_)5O(JZCwZV)g5mGSn?)=hO9U3hz}i-ww{HZ>?Y7=FG4S z_hs#k>toFw?RgeRlLke^{$(sXTBi~x_+NOphp#qOOQKWD&toDv#`ev2qIT-My76_B zmra>Df8Nw-vrkM9gp)72AsRB+DYrAbl$cmEYtGEcb(7PB;S3Z@k;P1+cs#})Py9b) z?F1*_^F1Oqzr?ad<@u~%N}2t(Wi!9e@hAHVI}fg6wLE@X}|>tidUD>kBBV_URgO?^{S zY@IEsPOo3r5sNmjidG%NZoV!ST~pr{ZHk>9YmKgm#hMKNmA0L12S`3CV8|c~;wI)B z#DOA(_A0c^a{R@k<@;NSBiTZ+04Nf^Mk6ADZK)Lsxr|u!4IlR zG@(dRp^RxeVnI+3 za;bx$9+a4=r4535P)@EbUDIN)-jM%)t{MODee=I^O~{9)3~`&1fTj%5u8BM}We8mJ zD)hSm`rQa$V3rlWz}h(%eRBVLHf3r5sOjVSFVl^q&8^Y-v!~6TRyS?@%xQ}!PpX77 z+dM$dIU=C{2K$k0AbEDc$M=1tVZ`}|`M8Wxnt{b7gK^GCd!b~2 zvJ*r}Gg~xr0!z~j7$rK=)L_8CU_#ae&44Ke6SBwKYb68ZP8PpuX6r{zb|v6oFxi!W zQxR7Jt{6;)1j{4?v}dYV+QRBjo~rsC>hy!b)C@<W^mg!N4;qZs~Ht?Ou8)7Z2c<6Xt7b&adn zV2rG9SQ~3^gB_Lnsn1MjMwbDIH649M=RvIL*^{(b0VUS-oQd`f*)DXcnXD!}#uF>< z$<@%jzGYnuf_XyJH*Nekf>8IH$+C6TK?pK4PY$lo7Ins%;n`Y{pb}(e!7TU)Lj(MC ze2cB{;AoBbsfCR!o1-0*9AmC_OiMW?!Ab}(huk{Ra2l%`S;z8ZrAR}ibp;WFKweik zRaS~TRcT$(iFUJO0C5+J1E;amMlNJ>zyniq%!OI14M1S9FlUNppdE8z?qqwmWPq}Z z#F?#Z&X`5oF)_$eqIOImFj%A=laTc6MR3f~m}HpaKgGAw3J(;Q&to~FsEw7Dof68D zlMM}5OZ8;K)MP_&0Y*YbU9w)RZDS{u*XscTX=qKo9yx(fZ#}$Vuq=`5JwcX7RUQ5GDFSboKZj87%A6Hqn@*|qS7GD z=o<&jB98?3pqkM)R?U=iGAFM&OVppiYWtt%Hh`v*vl7Fa0Zk=m6&Bf-Fqqo!1h-he z?VazQ!MGJq!Xk%OK3l9%rY%8&JEpZXx3)(c zSH_y!8&@^PS}{bWz&t1!kVQiVqLTA1IIGTu$DMCwW@Oprk}q<%S(xb~;@-1ac!bNv z0vBW$F7OyYxUk{^mjQ$iMOu4!Y+{J&11$!zI_zNHm`XDWV15WUlmhU>zaTa@^|1T}9+DL5ysO?Ilwt!Nb z#I%SDklJ>N`De4T%AH0sB%+#~MkRo#W~YS?Tqa47d9{U6f|rVeXR~1C)gB>f;cBCW z0CgNdXrYHBgch!~#HkB;SQMSZf&;Gg2uT;$8eIga2LVDCm-x}JpcA~+^4--r?;MuI zoLj9>u00@(R;N7q7O*|m_;captC@&xt$ z;_sW;(n0qdEhb3$?za*h&4lE;-^$Lxc*6W4C)jEE9p!2&eYy(SnhTFjw`F)$0D6GG* zLb0%!J7WEL>{jc2QTc0(fcTso>d&^q<3&wIps@42^I0=ro`k0R7{<9QHbD+r02m*$ z^neD00WB+0t^}zd2DGf=5>t}sdXAUlBl6Vvm{mH?-T;H3t@*w}@#BSTLp(o}1C8rX zx3F43(03e$^suf82sMS>&k>r$!suFx3|R#(8N3$AeE-l~R^Wbzz$bWtONO~D03xF|xo=RZv!}=`y?dYwI-~3a?MHd6%U(mJ-c``0O&O=Z?KH*CXm@u-@JG|iJT4CO z;yJzbUdZK^opMx_&QLql+`2N>iWO|0B@QiT{j&PlX${Tzq;F_%Y;Ib%rn#jpkBL+2 zS+pmI7>TtB_;_zamgYI#PM+M_+T2GxKt{j+} z6-RH2onGIB`K*byB+&Dko9rn5jMg_r^(q}};|^tk%IGw#%v+mJ$L!Z8dn-Uoa~n#~ z_upztY?kTnh6eQ4U#6JuOuXfu2l0$!3(8c38du7aWC6YYcQ;mSJpk0NTi3inRo&3s z(S(r!ov$6cD9zE>s#T2*jhL0!ZH%sMYTh7ut-;3xZNYdOH0^Tj-%5%;J+^*jr5&xq zPK~V7Eksr)opn&lNZ^*%jwbp(ArX}>2(4;uULWmflD0=d$YB1|&8Gp6HdUyHrH0bP z!0lFMT<)o)VZEV-04ysr*c9EdeHa2V)G8aDp2#xNX$GNP9qO1F7|1ok5Rid!oR&z) zQ$s)ohH=Fel#a`lwq6{Ts3_w!nsX;zEh^P#spGP>z}9iuT8gdXvPHknWPP*<)U7k! z@rt^2X1W=nXmy$iu4~nRl;6I< zN3AB2M`If{0^A`n;*wcdOh?>pB^n?j?zR$15^=YcXn>4>2^OF<9z&CbE*H{d;ZXx* zp`$kJ)Bsrsy1&s<3@e?UzH%%4i52ZKUbIJ7##S{pq4(9xo~;#!ZQc5owhp-oDfKKB zm5m2sb;^vRo?WON9TGupdc=L%iO>=T)a}9Fre9ogB6M3O2rv;nn&iYd^={sxeqqOWY zQ$t>!zl+x5n!{0A%kReQs=$ACoWOsyveVN}f&9&@mZ4A8&+Iy_1`T)8~cRK%1MxUkY_`Gvi(pA4wy<~8s zxt~=p8O{{aoW#5Dv*z4bH~J%)#m8(;)}!3cJ65}5-$!hGkCW_hSK-LmB+Rn5cAQT^ zAy}~%jGafIHm_?zEuhSCeoiIIg_TN-3u{CDcPi=H+MiVkolYL3lH)usAu5s@SZ`6) zizh3;3rW8#XtblpDkg@0x~j2ty;NQPCf>~`SJM(}Qr__2=r8`C^!Fdfc~Ydm_Nd`P z8{drcUPsgx%=2`Y*t|+BPr8cu%m1*H0h*p#V)|IgW9)c0iK)*aIjCnGXK7LUJ{vUr zC}SRHCnHcd{w=0m%ch9t>zOUu*6|)=OS-X!{v30Ke4N?2$D6Dk=hW+@Nz!N9DRNd{ zCKvK8?INk370&6pCel8bEQ_h{s&=Q+&Q#;wQN(f>POi<6SzUP?BYJ7E-Q#DZawY$T z_(yS4Rg$+Wz}#Jd%uI(4)3^NP-txryj`lUpt&Qy)MN3IiL1D=imbA(od}qYaqw)E& zF1B*DTtc=MKaoJJzn=9=#(5d}x1<$S#XLVg*v@HhZm(arjJ{i9 zE8Vq(`f&EwX31Phu+lhJn=``BS5#QK)i=`jP8UKondZs@wI<)CEq~pz9ixL<(fk>^ z`UI!Kj?_+`H>YOyyvfV($NZUf%jy=*!MXkTX*1{7PEP0HB%H@5Xc+cy`&E%|(C6u$ z>7TO!{yeAMcC?#mH^#D~-6uOfF@~i@CVz*sSH!-){Ox?(U z%%qN&C&qroCMO-b1bbE#PVyQT`|r21WIRblv7Kl$I*$$c%H*H;h)DGHlYinP(#D@d zZ5G7lO^R=t`0^_@RNPpIZT@+-KZp-}eC>;xBW!+oMo^yHQ5u+K`+{g+aNAL22Mwm@7|x z2!T!EkU6yV41_PPVsYRbwzRxBD8GIw4dsi&Rl1FI&Qv^dkv&b8#}|94Snw^IQC=F9 z2g4{&=dq<3MY=qlDwURvu_wy%*bL|+UjCL%F7FeR@hT{vfbxA(<-sZ;l<(7Xh}H?V zLdwO6zd?uPu1-QIU+(IJc4f<<6J?`BhgXQszp?qFD_k2TqI`vGqePUifQ^(6ZHfsY z9Uk2c#Ihr-YQFY-8r$%-tW0dfs#QTFtPR#x`SQpNqT66yHGBaD696SSyqe7qPd}FR zyGPi7g{D8YZge>(fpc|GZV3@JI9KQO*R>{rbM>%!nsc(lhjzmmgPQo@2xr#O5#s}I*6D|Y-A)_3POENO`u57gq#tsw<93=hha zMdE@QhDQc#@l#O4@UhFZ&Ql#esvDitcqipIdZz@JeJa?Ga`m1H_M=?Ar-J<`=v_4+ z&EaFaYrw&8S${Jo8TG5-(5)m5m5g=UkcLXex@|~9C1cTsQ>2#C5eCARhUXlkB{dYv zRxB`jlB1(rMLMdO5R|)GP*Xapm{2fCt0^5-Oc=eyu9H<{AW($O3ZIA_yDp=tNc+TJ zDE7AVbTQ-;f9BK-@SE&*)eP{P94^!RGQe;0;2Bykj>D%)y>vT}lFYqkcAMqO?x3!z zu6i8QHPuxQwk-KnsAq|a8=C1`D29H=mXys5*&ZIf)z441S9Jl@#uGK zz^FM)?p`8}gGSalYEP69$mbx?=cve^IekyEHzP0r`H-wu^!_{BIYHOeh#?xr^;h2`!ZGi}Q*w^g`>vdeOuJdDAPOM^|{rWEzGdOm4>FM6|OX7_!T%b zRD8$?E3%TaF;2=exK+Nj;_ZL1h4EFP5_dCt_0gNr1l4vh8r|rgv(fQfqq`kUjc#<$ z*~l3i-E%f%o$8X&mgT7~8EsjfiY?205>EyBoC>->=xyW{-!H_=Kd?W~eRuLj^<;fDk6E1PDTOxcjCgdk2pDSD7u^4QzpZ7)CM4!YD4j09NPvZqRf(NyF;>rp*D)={)I!&joR+$L#TdZ zq^Bk)3vH~H^8(1}>~-UidD8BLWYp-!p|!eED0?OwqA4j{^h{So>NRIZU2aNe`kP=X35)aLAnT;>r1 z+1YL*0%*k9ZX*J+5mWiuZY#j(99J3&BR$7$1;yW-gD?T5T3RWc1GeP6+zD>BeCJzY z^N(znjF+MCkj+-87>(q9L`nI#n7|JeCZ#aNNKlxR|6Ihi$g_1I1Udk!Xcj;)I@bh% z0OFkeT#DmRq{uwaBZWHy4s~ha(7-wpMg~s-g7#@0E7^Xj6rYwB?J)Y#rwzpn9297nnV)$-`?==f}$QPHVE z8v+`lE7mnPtc|*(tU6J^0f`xaaXu1j-GCz#b;{LsXHCW}*mSIglal%tc_xc9h-R!h zzy^~ZDVk35w_E6*5B>f%Z*WV5R=5oaacu0G5ykFCrGQPNF_iM zV?@k)po>x}-R+x+?C`V)*o5 z< zMS5vkxI3U*Ey@auE!3Ili3C+_jbFxa3JZNvRg1oeT##yrI1*uNPlVo3qPd_KA)N?vb?_booVh^$Sqq}Nk_#I}(PW7>r< zCiwmq3#;TDv7GVsvfmQRT~?@2dQcD^bhGiGpz$D?LOdz^SH^>aDxOPXH}vT?%B7~N z&?i78Iw0z~%{Y(>eTv^^^`kEc3Y$VM!l?``c@UtXB@epYc#w*Hy4@p%2i@V3k^=!M zO9p9p2h^4XgvRbLr12oZ-4?@6p%j@z`GCrl$OP?fV@g0-7!vEkFy(HmVumy&a^=8^ zl*;M4NpP_{J-Ns}fTl_0Va0bEQwC{7MK+i(g|(pOUt7Mu;aX{`O@2N(``1>em)(Lq z#8Ta-VyRX{Me!FbQylj5h4K5WP=PdI2*e1>QiDLqm{6vW2`T$Ql8Pc3L&}5_lNk`$ zL{V3IWCnuFfJ$aS$lPg0Ws)jOrmQWD!f{ zR!b%XG^E7%VGChSq<54B>BB@yA-ai<|8dLLJ1iyy`NE9Htx!*SHNbB>!Tpx+cjB%f zzcRkx3KdD+V9Uk-l+lfCbR$zpH>mXYu!Lp>TZ3jx#U+!;-mv7S zW&p*>7XXz(0cCDP4KjdW{su8ua={ng^yFfY3sBiJnS3D*tfwAe(7ve!Lq%B30=jak z)htq6xlsHqPcE8G0ZpUHS>Ey*P0sQb@veadQk>v>mhXQsxrpy zQ~iASgZIGi&f1Y0gyggwHLe7B@i9IH2+bK$)vO z0T9eTC+12nc*0>%F7gCGrL0ut35Sg*0E70h77TKcCmi-$;6j@{Qkqx*4XGSVHnT_{Y36k4LYqBWaN5G$HqpcasN64IPAprP9)|#B zVLh<`qDfnro>&OVCT(GQVo9foWh==QCl>;QV8BLU>}{!o?^yqx*2Mdc&Nk+G@X^m&frz?%bD&?4urUZ>BXUA99gE2BUAR3 zMn*@;C^5MRtC1c71Q`L9f&d}o4x?N^$hd=54p5E^46E;8RkP(-NKjgR2OBs` zdZR;*ypu8YwFU&s0V;06F|aZEb0=z3mf9l6xey z)8WR2x_c?zZjI<24Har>F1b@gZ>x;PqL^P9h1uK@_ky`s#HfaUvon%~_TJ9)cWo9F zcZc!&EaUewh4f0Z(7l^p?5(cKKO(qv^oDE4lK zdu56infFLqnMrO9Xh_Me?_ud-O-gQkk4Fl(-eU%&EJjm&99Vq@0fTlAL*%!rmZtbU zM5`fua}Vn=T6Q-SR^4q6i;mKAq4=*oxoC<9G;+}t|7(vo`TehnckwCkm27-~GG8Zr zrRF$SiHR@%!6Mzdi4NM7!N+RvDjT)j$M9K8Cdh^f?l&gLRwj^`)R;{sc+ltq2)Y1N zS9bux=s||Pdulsi9P&PBbO8)qJZN-5P!2s08eL?QCVyje0R&wDDqR4|TwB=)5WIgw zyibNIa-85J%=ZFRF{`U85>@D}j1>K&zvLKoAX#=A+3Xx}e}si13P1;s8ZXT;UMf>a zMLEcR+^8r=sYqf{Q4Xo-3C6}tB>l0iqdCu(9K$H{_58p7dx* z1As~c$dtKy{|*qOPkN;A()}JOP2Pa&(pnDP>hbT7GkxI=7_9cQ$S5r&IqiOr70^?R zE!UYe76U4O&yi#CQ!Ju3(g0;)G=OXl2pd1e#xIlpPEgwTDK=rLEq6C_NU*0pIcZS= zXqrf4@zZ8@M_Dj`+LH@qpYcd(Q30stmmIm@_Y8}aX+daF@r*}`Har{mXlXm|S&x<$ z70-IKw4L{?M+Y&Sa&zq?!hc1=@f;stot`mHj`3@cH^PbBO+{*L1bNS;3fLv7bG7FVT z=g&oRe`mZqS9!O@Akd zl+JO0^*d3ze=d3D9~djwE_C{$3dbcMdmrd*O>3U?iER~5}S`7JCN*+9eH5>ni)ItpuRtvu_Mon9WsT+4$A%$ zW5eaPU!Kyg#MFvB((daFhd|^#Ku`c6DF9;!Fe-Z8j2(c`!0Sw&FA*&=-|%Qjd4NiJ z$dtKy>;MGm8y+c?_a?)Uma0~6XBeaA$+6>>aO7;P$T9CK^oujjm}ld6((W zn>_i6@-8u_Pn3Ko_#yLs3}>6xb*56i7G7nd6Xz>8lbB4BPj2>Svp@wxYXH>(6%dU6Z2AfyTK;F&4=dCL$RBospEBRy zApiX1b%^QA`%^c7=^btcWQfNB&C%Rcdy>2H9tFeIk_1_ZTQA(QZTNt>TqF3ec~I_;Q&GV4biGL1<|H&yf&#vB#`2^2@deBCl?+j zB52G+Q}DN@zlG%#{4I-v`7$_cffM|m`Thlmo%^#6`*WSn>vOLA9^dZ@Q2X~R)K@xk z0R;Vr?03yL)+tb~Dig?63&>UfX*wPdbOfk69w0dV({wyQ=;)vHWk`$th!gyY`7Yw! zF7{m@EA+Od`E?VSkqxN|*P>T!U|l*p91y2k;6^jwb=J?=b@lzJSX z^3I5yrsC&u-Q$2kd!9!NbiPMRvk;)EmcFyj=Xz5qB75BV9w|E11s*B&CqPpz^`{HC zUUtSKvO`_q(W3A+uJ`96jAkJ~)hPf$yN&C$BOqklMx@j!0MRM7alJoBP0-M_r$-7`6!-X>t%;uc&}QD~Og14+z5xu9qJKrQrqFE2<(YezhkT z`7)q#NMwTd)y5$KWns5T@a1dJ{yJS1o>d{N9I{BRsID;%2?*M2Jh^b>4d}|{S8`qB z$pt~K_2i=21JLM;oc&tuk3-Q)^7dDQ{?;g13yl&bJa6Wq9@0&taJ^fMXGV=@ z$`tZU%D&ZjW>k5m#N?S#^32;gQ$`1Zwg5wMX&GQtbi46PKxpfBKB!vG@lo>3J3LzQ zOhBb+WXfFanSda@!y|=f?&fTsu7(B?z*GY*e6j5|-V>FcxtnOoGXdcNyZPW+x%MC^ zJ##l7GFQums_yjUBF_X=o*9*%c_)v^t!OYK&%D!<3!Zrwy}_Np4f%rzLM}H1k{`m$Q55bzy=QJ36A@z$E`$( zQYZKf_x%nkTR^?In=o{7Z)Gq??6MP6MAhaH&$T#MGBdNx?609XA66{l38CS}DM&=mn0@TG9d_l=1@Ck(8y>mtXW~ zsV@U6eIirl>Oe|BkiO`VqA$PXkzK%C7n{k*qVM7#93*0 zZFF|W`W1LQ3Za#4`mKaE`IZYJ;``!!VO}4y;pg!-tJ=*Pdp=j%;evRgIm0( zlsdo2;&U^yOKR=BxgD|Ajryx!UUe1w^Z2-`XYe}KaaraY#yR%3EnYcFsb>Yzu6Jc8 zsArpxx^F8!DCJ91XW5xuSc@m~`1pQ%Ejz1AV$7}TXWo6t)*|a#^xF{P{Zf9)qyjCv z9x&DYzFM+(TYJe|J1pxtCR4vMQEeXY594z#7C#6;b~|*9*z4(NXJg%9lv~7wjij=Vm@xTzit)|Sq)%OVuR zL42?v;bl`#)m(8%?=ScFpQE|@4Of|_E<|FWsAARP;-P$6O_h7)lCDrz;XaFEiX}3y z8gsH{ilb})K>whLnrXl=m1(PG`!N>}V@0!9RSeW*Rh1W!f6a6f@r#Jd^XrFutZ{Oi(^>3^sHbb4*r+mXt1IjyXX_XHg!Q zj`fc-%}+2)WtzHwiG{!^SdQ!^tdUrL2obiZ>(;aDv)-S3<+eZAI0BDl}=&zhyV zCmQZDtyOZj9e*ubAU+$;TWe}v<#%fx zbG7TRbboWT>#!+cy2jsVd@IE;m1*kkYpUa4&ssP(!@Ev%n9rpOBsqqs;%zSZ_Fi-~9;a&(RZsb|#QXp9CoZMip>6K1Wx5^O zmMY&Vhg@_!w5`899wY=w+Wj4)wS%M?Nn~2BlqB8pZ)9h2tcmq(A?`gX&`aEOfCa<_ z=d<)ht^(-B=tj4H(v8uLZvUhkqZ`pbl|!XtAU)GRUJs<{x>lJ)XB0js5ci#HiN{Cr z1!?h6f!!OcA~`2)wnXu0Tok`|9`_GM3I?&wCWH~x)=*#HB!eX?SIl(I}-%fF8EMJs%B{j1I^)YJZ4zce}UNjhgqdr`*=_5G;qP`tg zUm5U9B~jlFYsgT!bBr5e*I2$?;^J|9N!m3O5j+I!-m}f+BlL4yg17OKe)gi>kT&4!pr)eWgTzGP6u=8~{S18|Z=z zHHDMvZW4PZ@uKlvwc98d5QMu)!Kb5AJh{9FPyUKiCi0H7Jr+Lh$ABGPOvb0a_+TO*H+rv8FcQIc zuTd}{`0h0d1_a-|M!|SGncn|Z3I+fro(@(D29%jv!GNILXA~SD1>a8!F0I3b6Saqe zM3CHXR0{}_`;BS=q1yY6Y6(i!-cPDsgI41G<%cZa;|TR$92J*M!3z|duq562Cp>3< za4%2UxtIGz>tvpr{t&61Mhx67LQGAU5kvgqP9Cg$#B_Ug73mQ(V5qA|kC*`iw~HMA zV`{({4uGEdm`6#if6NRR$VF2gBSVrs@B}lioV)-@*Jw#2`8*`H@56r=PUJnsjw!r% zI_{$Mk&nO2r zjC}(dKl)WXYeo+B2=lXM?RDnTSf? zutMeXUG+qA%(ukox7g?k+^oo!c10q}yk+I6X#x)cAorlRU2zu+w>1unu`~Ip>A03rD&0fgr~0Ie zd*EURP3)hTW~w_?pBVp8cd9-y{voea{Z;t~D9Jzm>QRz{{%ZU~-KhF2`9}{Z$R-7S zuHS;+G>Zp^;L?RMIkG_bxp@m75DopD-h$slD}p2^__gKx2W)<$6%{q*Ja=b=2gUEs z;3?vZg}h+rY+j%CHC@yjj(U>F+~10p*?eRLZY-$XXe6SBZ|QCdP0E0%;ag+7B&z;9 zWjp+hHsLmdA*42aXKaUD5PoNDmqcy)o@_U~?t5c4B!c97V>UpLd~eJK2(x`}%tla} z?Rzp?D_V@q>y+Qi}(`WqZ)sM@M5MXTR_TVda?xs;l)g^W>Top+r=R) zgBIg&5NF;-Dx0u<4zOqV>8#@!GY9+uQFCcHsrX9=^bc5$Z-|Z zKjwfdO*p!g=B~!yAl&H@Qp_7*~vLWWL+bvRl!C(X=e_?LV;Jq&sh-*j9%gd?SV14?;!qdeJWNeH|ZM zu?s4e>QmQ>cCiE%n5wQ7?P54c2&Na1wmy7xOWn-(uoekV9Ea559m9?G~n& z^=Z_mTgATl=)kucJ0cMzx0>)3K#<(Z^nxA`cD$A88^{Eu9dBjmz#V8Ut~lMveD|WY ztD|Cn1%CPBqy>C_`khQq(6~;711QgWe(~-CNPM?ZCh}4J-Nt-?sQzwaK3pe4h&h?B zU&S7egc`ZW7*1U|+G7ltPL144hASSj*CQcDdyUCZ2DR)Zlif!q!`+$(neQ<);#V-4 zY{fl2;D}2z)u4NJ+Jg-9D-F2v5>2PrcoGKOPNQ~pd8U)$Jd2!PU7qP=_=OxYR|eJn zFqx}g#ls#6HR54oDU^Xk4;xEmP$M2COI6Ru-{^M;&{oSRKoCA^>;(wIM~%GzVXsGx zy$DKsJxcc4fTrRm&y&peqS(KPpPv3CwTk+fLsojKtCjA39b+mYqt(!ed{p|Bu@WFE zeacwLA&H)molHEr7|X9`JUVLSGsaXX2)bv?km^t?pHo9>H2|84;A8b!0tm|I%#aEQ z%I9cErC-Bw2)!WIE#;+C@izv>7tFv2h|cyq_Ev-ECdBqI7fFOCr z47-3Z|0`zLB`D4R3Jtq-zJ)tDe`3CO(cooKQB;EMjyG%YcwOoW%s^M2!XxQ_qPr60 z61ZeSVYKeB>#s%%H2a3JEg&R$!}tUsBzeR5L>7tpmKu2RHwY0YtDFgt@{Cgeg77VJ z3NmdLwfY@0ZTSQQwJKF35ggtzMg;_icZ^X1!QmY;>PEB?cSk;CzQ3T2Yh@er#8*rC z$!QBEd4W@Bghu= z-o@cAwh#xFV-P)TG^%c195$vY~LF=BODT5G_5z%F69VGz1a+-!b1m#f$ZPP1<)1PbScB zav?6BmXPCC@G+ylH++!@)qijJ0z$Iyjp_lx_j{vy#Kt@RAEfFR;BTn@2cvpG$}_45 z1mO=x^?*?Q4@UI_rRskm)zeF22$e?^;<;Q@Ht@635KP!d>K>u!*yBD_zj2(H*>x8kU{HPx%?fe697P|0tqn;shIVxTrV|M%=%V3gr+$aan#$m z?=l=huNJ4S%~Mq z_0vna7+Avxi32enth>}iv>*$FmzszcKoDNa^^yV*hPagLB?Uogh)X%9D0+MZVc1u4 z-_>Y79v>Oki$}yKi||9NXnU`;E4lu%labLo$Si#;cbEpNfao2@ASxhwhcSo@h!)Bq zg8|T1#I30@2@oO+V-OV&Eyy6JK_bN2UeA5M5;d!NOWO4m5J(D?5wACj1FLzz${P(M z73q2-PgDbkigdk^W8hFEsAX4Iofk+sb{U-m$`V@VfKc5oqw@mN`7KK4jR5d|1Z0_- zNa?p2r6U)Vw-}`ZLg}{{r4y7&zlD^(8cjqD?(N)nCzQS@+VwmfhsvVm%uv2)VS&u} zF**1_n%X%N@y-<9kj9Vx()Kk4;@(biCp3M^U|Ixksr?WYOzXySsaV=OjImTK?HwkD zL&nk~c*~HIwRTT5T2{fdyN$V2Fzs%lrLm{b3Esnf_n|E(AKMoEF2=w+@Z%i+xgiw$ zc@M`o2sNaT27x_XuLFRfc|a9?0*JDEc$&Hz1PIOV;dm{MRvduP{2pFBR(=T){Pdrh zvP8)k=@f-zxV>GS0x4+jUgH#ivV?XDK#=b>PEklsu}?Y0N&twq&o~7jDEAqs00iYe z;}n1pZJ%)pg3>AWkyFqUK?r$$koz8jBIk5bq`3FBgx(_hqdyRwFQWp)B@KA%o8np@ zWwbLUdRR9`NQbngRyb4Y2B+_s_ z1n%JkALYLN5O`i!fiM4KLLYH&G#E4jKe`e@HWWhnD8~^53EYDOe#``T0zr*{DykI_ zWgp}E_9q|&ehhCIOA7-+jgN7>-ALcM1f?1u<2XB{Uf+X^@LQbJhYQeGTG!%tuMou} zqK8<98hB9vjYJ8x4Ff0%w7mgQ-EWP(dyu`K)b<8|pidfm1A_8NV{brEK56U?2tl7T z_9iF=eUj`=Al?*;0A>OqUehzItvgDco9K% zojrYSi(GRO{R7GIqHH|A85xfPu<4TXT zad%y@YQistZD_==7?qTl(2ug?b$!q@E!cQ0kvtD3iKIv_!h4Fj`q!S2hojP5NB&wg zmBis_E;f3vqwid(HsUK5n^FST@kpppEbb8~)W3C(cR!W>R|sRQG2AY<^`(7QxgLp zi&ZWDo~-0iao40kd+Jd?S?8x804eV*njE;#Z-3<2a15VsZi$#H{F!3;!a!7{Ob_(T zqaYu&pB^foX&x%ivBKlTWy1q~#S_!8t=2pp5tj1R^5ycN8Li6@_f8M2z^mo**V=JD zEnh8{SJf#Ff!dRC;#&GiTOc$wQ;eDs7}X~;D1Td)(s1aUnPT1#N0;Q8#e?iAvOIoU z;S>LfgNQEMJ*G!L<=L4fq#}@`C-UryN%&1+`NMemz7h-1Vv9YK0ugawdLU7Zo*Af^ znvdm;d6+hgLmK(3YC2$(Q-aBi$Y<<=exD52#7}>9`5Ct&Rw-s(5C|7Wl(kgriu#)( zkg^AgjOddTj^lC%nNXff^B!&yh#o~iuFAr<7m)h7MKpx`K)+?GniX})(8gkyj3Tj$ zu{u#q@EOjFBc%pWNsy&d7&6?l7yX#nJgtt|lLH}f&aA+&c&|`@*<$+rwBEYK`uEca zx=+^j#X5nif$u@qzFJo0vwgA1)_JJ3FQy7b26@U{GK{}KU4K!Meq}39(UGmoKt~UO zVeGB&ogik+4vdIbgb+7|H4i;XTd9rZzF12MCbLS5&XlnTx-ZraVsy8SUX>-$2Wc7P zu{R$yWroRv2!j?Z)MOC7nw_Mc7=}GSSMAba>fqH==4m<-z1pRNRR^;TItvpA&}4%^ zHh2n!x|1m6tb;+O5qkIFlTJVSh1$W3QabEgXn>TZhl$H;0=JeAbLAj=57R&Vj1pit z3_o-_0V>3ZKGHW5v8q$N7d=VSEK#{g*U7+s4z#OGu5 zZ+OZxe8g>Kqf^od>7U@6y>o70%9IJ%mm^c)^psD;wJ_>b=H*hEU@|9b3Dmo#czL|S zE`$Vh#*Sa4KePo~_m`iEv)~_Z^9QS@Y9Ww|rcTwrkSY(}`Bd!GQrI3ykv9tw<{c`+ zTzoM%u;_A;;J`3UGv(Y?gVXnBjHZaGUd%@SW W0sIT%UjqJx@Gr6R>stG^@Bc5=Z%R4< delta 23669 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 From 0d28c0068634ef3c863e7a56a34c2c2fce222164 Mon Sep 17 00:00:00 2001 From: Luca Joss Date: Wed, 7 Feb 2024 14:07:11 +0100 Subject: [PATCH 15/15] Add changes related to ICA from v8.1.0 --- ...tions.interchain_accounts.controller.v1.rs | 5 +++++ ...interchain_accounts.controller.v1.serde.rs | 19 +++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.rs index 00e306a3..81fe9836 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 b438d22c..75bea08f 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(), }) } }