From 5352b6c10eee30fb0bc589cd14f003223c1cbd18 Mon Sep 17 00:00:00 2001 From: hashkid Date: Fri, 3 Jan 2025 09:41:13 +0800 Subject: [PATCH] update side chain --- Cargo.lock | 2 +- side-proto/Cargo.toml | 2 +- side-proto/src/prost/side/side.auction.rs | 121 + .../src/prost/side/side.auction.serde.rs | 944 +++- .../src/prost/side/side.auction.tonic.rs | 239 + side-proto/src/prost/side/side.btcbridge.rs | 23 +- .../src/prost/side/side.btcbridge.serde.rs | 50 +- side-proto/src/prost/side/side.dlc.rs | 334 +- side-proto/src/prost/side/side.dlc.serde.rs | 3016 ++++++++--- side-proto/src/prost/side/side.dlc.tonic.rs | 448 +- side-proto/src/prost/side/side.lending.rs | 623 +++ .../src/prost/side/side.lending.serde.rs | 4469 +++++++++++++++++ .../src/prost/side/side.lending.tonic.rs | 1213 +++++ 13 files changed, 10456 insertions(+), 1028 deletions(-) create mode 100644 side-proto/src/prost/side/side.lending.rs create mode 100644 side-proto/src/prost/side/side.lending.serde.rs create mode 100644 side-proto/src/prost/side/side.lending.tonic.rs diff --git a/Cargo.lock b/Cargo.lock index 59f0820..bed351e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1272,7 +1272,7 @@ dependencies = [ [[package]] name = "side-proto" -version = "0.1.0-dev6" +version = "0.1.0-dev7" dependencies = [ "cosmos-sdk-proto", "cosmrs", diff --git a/side-proto/Cargo.toml b/side-proto/Cargo.toml index 0cff68d..5fc3990 100644 --- a/side-proto/Cargo.toml +++ b/side-proto/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "side-proto" -version = "0.1.0-dev6" +version = "0.1.0-dev7" edition = "2021" description = "Rust Client for Side Chain" readme = "README.md" diff --git a/side-proto/src/prost/side/side.auction.rs b/side-proto/src/prost/side/side.auction.rs index a465287..eff4ed6 100644 --- a/side-proto/src/prost/side/side.auction.rs +++ b/side-proto/src/prost/side/side.auction.rs @@ -106,6 +106,7 @@ pub enum BidStatus { Bidding = 0, Accepted = 1, Rejected = 2, + Cancelled = 3, } impl BidStatus { /// String value of the enum field names used in the ProtoBuf definition. @@ -117,6 +118,7 @@ impl BidStatus { BidStatus::Bidding => "Bidding", BidStatus::Accepted => "Accepted", BidStatus::Rejected => "Rejected", + BidStatus::Cancelled => "Cancelled", } } /// Creates an enum from field names used in the ProtoBuf definition. @@ -125,6 +127,7 @@ impl BidStatus { "Bidding" => Some(Self::Bidding), "Accepted" => Some(Self::Accepted), "Rejected" => Some(Self::Rejected), + "Cancelled" => Some(Self::Cancelled), _ => None, } } @@ -192,6 +195,34 @@ impl ::prost::Name for QueryParamsResponse { ::prost::alloc::format!("side.auction.{}", Self::NAME) } } +/// QueryAuctionRequest is request type for the Query/Auction RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAuctionRequest { + #[prost(uint64, tag = "1")] + pub id: u64, +} +impl ::prost::Name for QueryAuctionRequest { + const NAME: &'static str = "QueryAuctionRequest"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} +/// QueryAuctionResponse is response type for the Query/Auction RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAuctionResponse { + #[prost(message, optional, tag = "1")] + pub auction: ::core::option::Option, +} +impl ::prost::Name for QueryAuctionResponse { + const NAME: &'static str = "QueryAuctionResponse"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} /// QueryAuctionsRequest is request type for the Query/Auctions RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -225,6 +256,34 @@ impl ::prost::Name for QueryAuctionsResponse { ::prost::alloc::format!("side.auction.{}", Self::NAME) } } +/// QueryBidRequest is request type for the Query/Bid RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryBidRequest { + #[prost(uint64, tag = "1")] + pub id: u64, +} +impl ::prost::Name for QueryBidRequest { + const NAME: &'static str = "QueryBidRequest"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} +/// QueryBidResponse is response type for the Query/Bid RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryBidResponse { + #[prost(message, optional, tag = "1")] + pub bid: ::core::option::Option, +} +impl ::prost::Name for QueryBidResponse { + const NAME: &'static str = "QueryBidResponse"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} /// QueryBidsRequest is request type for the Query/Bids RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -288,6 +347,68 @@ impl ::prost::Name for MsgBidResponse { ::prost::alloc::format!("side.auction.{}", Self::NAME) } } +/// MsgCancelBid defines the Msg/CancelBid request type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCancelBid { + #[prost(string, tag = "1")] + pub sender: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub id: u64, +} +impl ::prost::Name for MsgCancelBid { + const NAME: &'static str = "MsgCancelBid"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} +/// MsgCancelBidResponse defines the Msg/CancelBid response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCancelBidResponse {} +impl ::prost::Name for MsgCancelBidResponse { + const NAME: &'static str = "MsgCancelBidResponse"; + const PACKAGE: &'static str = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} +/// MsgUpdateParams is the Msg/UpdateParams request type. +/// +/// Since: cosmos-sdk 0.47 +#[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 x/btcbridge parameters to be updated. + /// + /// 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 = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} +/// MsgUpdateParamsResponse defines the Msg/UpdateParams response type. +/// +/// Since: cosmos-sdk 0.47 +#[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 = "side.auction"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.auction.{}", Self::NAME) + } +} include!("side.auction.serde.rs"); include!("side.auction.tonic.rs"); // @@protoc_insertion_point(module) diff --git a/side-proto/src/prost/side/side.auction.serde.rs b/side-proto/src/prost/side/side.auction.serde.rs index 9e2fd05..f999d5f 100644 --- a/side-proto/src/prost/side/side.auction.serde.rs +++ b/side-proto/src/prost/side/side.auction.serde.rs @@ -629,6 +629,7 @@ impl serde::Serialize for BidStatus { Self::Bidding => "Bidding", Self::Accepted => "Accepted", Self::Rejected => "Rejected", + Self::Cancelled => "Cancelled", }; serializer.serialize_str(variant) } @@ -640,7 +641,7 @@ impl<'de> serde::Deserialize<'de> for BidStatus { where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["Bidding", "Accepted", "Rejected"]; + const FIELDS: &[&str] = &["Bidding", "Accepted", "Rejected", "Cancelled"]; struct GeneratedVisitor; @@ -683,6 +684,7 @@ impl<'de> serde::Deserialize<'de> for BidStatus { "Bidding" => Ok(BidStatus::Bidding), "Accepted" => Ok(BidStatus::Accepted), "Rejected" => Ok(BidStatus::Rejected), + "Cancelled" => Ok(BidStatus::Cancelled), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -1049,6 +1051,396 @@ impl<'de> serde::Deserialize<'de> for MsgBidResponse { } } #[cfg(feature = "serde")] +impl serde::Serialize for MsgCancelBid { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sender.is_empty() { + len += 1; + } + if self.id != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.auction.MsgCancelBid", len)?; + if !self.sender.is_empty() { + struct_ser.serialize_field("sender", &self.sender)?; + } + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgCancelBid { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["sender", "id"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sender, + Id, + } + #[cfg(feature = "serde")] + 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 { + "sender" => Ok(GeneratedField::Sender), + "id" => Ok(GeneratedField::Id), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgCancelBid; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.MsgCancelBid") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sender__ = None; + let mut id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = Some(map_.next_value()?); + } + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(MsgCancelBid { + sender: sender__.unwrap_or_default(), + id: id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.auction.MsgCancelBid", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgCancelBidResponse { + #[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("side.auction.MsgCancelBidResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgCancelBidResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgCancelBidResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.MsgCancelBidResponse") + } + + 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(MsgCancelBidResponse {}) + } + } + deserializer.deserialize_struct( + "side.auction.MsgCancelBidResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +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 !self.authority.is_empty() { + len += 1; + } + if self.params.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.auction.MsgUpdateParams", len)?; + if !self.authority.is_empty() { + struct_ser.serialize_field("authority", &self.authority)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for 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, + } + #[cfg(feature = "serde")] + 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 side.auction.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("side.auction.MsgUpdateParams", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +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("side.auction.MsgUpdateParamsResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +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 {} + #[cfg(feature = "serde")] + 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 side.auction.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( + "side.auction.MsgUpdateParamsResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] impl serde::Serialize for Params { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -1079,40 +1471,284 @@ impl serde::Serialize for Params { if self.fee_rate != 0 { struct_ser.serialize_field("feeRate", &self.fee_rate)?; } - if self.min_bid_amount != 0 { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field( - "minBidAmount", - alloc::string::ToString::to_string(&self.min_bid_amount).as_str(), - )?; + if self.min_bid_amount != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "minBidAmount", + alloc::string::ToString::to_string(&self.min_bid_amount).as_str(), + )?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for Params { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "price_drop_period", + "priceDropPeriod", + "initial_discount", + "initialDiscount", + "fee_rate", + "feeRate", + "min_bid_amount", + "minBidAmount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PriceDropPeriod, + InitialDiscount, + FeeRate, + MinBidAmount, + } + #[cfg(feature = "serde")] + 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 { + "priceDropPeriod" | "price_drop_period" => { + Ok(GeneratedField::PriceDropPeriod) + } + "initialDiscount" | "initial_discount" => { + Ok(GeneratedField::InitialDiscount) + } + "feeRate" | "fee_rate" => Ok(GeneratedField::FeeRate), + "minBidAmount" | "min_bid_amount" => Ok(GeneratedField::MinBidAmount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Params; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.Params") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut price_drop_period__ = None; + let mut initial_discount__ = None; + let mut fee_rate__ = None; + let mut min_bid_amount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PriceDropPeriod => { + if price_drop_period__.is_some() { + return Err(serde::de::Error::duplicate_field("priceDropPeriod")); + } + price_drop_period__ = map_.next_value()?; + } + GeneratedField::InitialDiscount => { + if initial_discount__.is_some() { + return Err(serde::de::Error::duplicate_field("initialDiscount")); + } + initial_discount__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::FeeRate => { + if fee_rate__.is_some() { + return Err(serde::de::Error::duplicate_field("feeRate")); + } + fee_rate__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::MinBidAmount => { + if min_bid_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("minBidAmount")); + } + min_bid_amount__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(Params { + price_drop_period: price_drop_period__, + initial_discount: initial_discount__.unwrap_or_default(), + fee_rate: fee_rate__.unwrap_or_default(), + min_bid_amount: min_bid_amount__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.auction.Params", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAuctionRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.id != 0 { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.auction.QueryAuctionRequest", len)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAuctionRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["id"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + } + #[cfg(feature = "serde")] + 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 { + "id" => Ok(GeneratedField::Id), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAuctionRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.QueryAuctionRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryAuctionRequest { + id: id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.auction.QueryAuctionRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAuctionResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.auction.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.auction.QueryAuctionResponse", len)?; + if let Some(v) = self.auction.as_ref() { + struct_ser.serialize_field("auction", v)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for Params { +impl<'de> serde::Deserialize<'de> for QueryAuctionResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &[ - "price_drop_period", - "priceDropPeriod", - "initial_discount", - "initialDiscount", - "fee_rate", - "feeRate", - "min_bid_amount", - "minBidAmount", - ]; + const FIELDS: &[&str] = &["auction"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - PriceDropPeriod, - InitialDiscount, - FeeRate, - MinBidAmount, + Auction, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -1138,14 +1774,7 @@ impl<'de> serde::Deserialize<'de> for Params { E: serde::de::Error, { match value { - "priceDropPeriod" | "price_drop_period" => { - Ok(GeneratedField::PriceDropPeriod) - } - "initialDiscount" | "initial_discount" => { - Ok(GeneratedField::InitialDiscount) - } - "feeRate" | "fee_rate" => Ok(GeneratedField::FeeRate), - "minBidAmount" | "min_bid_amount" => Ok(GeneratedField::MinBidAmount), + "auction" => Ok(GeneratedField::Auction), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1155,66 +1784,38 @@ impl<'de> serde::Deserialize<'de> for Params { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Params; + type Value = QueryAuctionResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.auction.Params") + formatter.write_str("struct side.auction.QueryAuctionResponse") } - 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 price_drop_period__ = None; - let mut initial_discount__ = None; - let mut fee_rate__ = None; - let mut min_bid_amount__ = None; + let mut auction__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::PriceDropPeriod => { - if price_drop_period__.is_some() { - return Err(serde::de::Error::duplicate_field("priceDropPeriod")); - } - price_drop_period__ = map_.next_value()?; - } - GeneratedField::InitialDiscount => { - if initial_discount__.is_some() { - return Err(serde::de::Error::duplicate_field("initialDiscount")); - } - initial_discount__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); - } - GeneratedField::FeeRate => { - if fee_rate__.is_some() { - return Err(serde::de::Error::duplicate_field("feeRate")); - } - fee_rate__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); - } - GeneratedField::MinBidAmount => { - if min_bid_amount__.is_some() { - return Err(serde::de::Error::duplicate_field("minBidAmount")); + GeneratedField::Auction => { + if auction__.is_some() { + return Err(serde::de::Error::duplicate_field("auction")); } - min_bid_amount__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); + auction__ = map_.next_value()?; } } } - Ok(Params { - price_drop_period: price_drop_period__, - initial_discount: initial_discount__.unwrap_or_default(), - fee_rate: fee_rate__.unwrap_or_default(), - min_bid_amount: min_bid_amount__.unwrap_or_default(), - }) + Ok(QueryAuctionResponse { auction: auction__ }) } } - deserializer.deserialize_struct("side.auction.Params", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct( + "side.auction.QueryAuctionResponse", + FIELDS, + GeneratedVisitor, + ) } } #[cfg(feature = "serde")] @@ -1459,6 +2060,199 @@ impl<'de> serde::Deserialize<'de> for QueryAuctionsResponse { } } #[cfg(feature = "serde")] +impl serde::Serialize for QueryBidRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.id != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidRequest", len)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryBidRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["id"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + } + #[cfg(feature = "serde")] + 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 { + "id" => Ok(GeneratedField::Id), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryBidRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.QueryBidRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryBidRequest { + id: id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.auction.QueryBidRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryBidResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.bid.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidResponse", len)?; + if let Some(v) = self.bid.as_ref() { + struct_ser.serialize_field("bid", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryBidResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["bid"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bid, + } + #[cfg(feature = "serde")] + 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 { + "bid" => Ok(GeneratedField::Bid), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryBidResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.auction.QueryBidResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bid__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Bid => { + if bid__.is_some() { + return Err(serde::de::Error::duplicate_field("bid")); + } + bid__ = map_.next_value()?; + } + } + } + Ok(QueryBidResponse { bid: bid__ }) + } + } + deserializer.deserialize_struct("side.auction.QueryBidResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] impl serde::Serialize for QueryBidsRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result diff --git a/side-proto/src/prost/side/side.auction.tonic.rs b/side-proto/src/prost/side/side.auction.tonic.rs index 78e80a3..8d48533 100644 --- a/side-proto/src/prost/side/side.auction.tonic.rs +++ b/side-proto/src/prost/side/side.auction.tonic.rs @@ -103,6 +103,24 @@ pub mod query_client { .insert(GrpcMethod::new("side.auction.Query", "Params")); self.inner.unary(req, path, codec).await } + pub async fn auction( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.auction.Query/Auction"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.auction.Query", "Auction")); + self.inner.unary(req, path, codec).await + } pub async fn auctions( &mut self, request: impl tonic::IntoRequest, @@ -121,6 +139,23 @@ pub mod query_client { .insert(GrpcMethod::new("side.auction.Query", "Auctions")); self.inner.unary(req, path, codec).await } + pub async fn bid( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.auction.Query/Bid"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.auction.Query", "Bid")); + self.inner.unary(req, path, codec).await + } pub async fn bids( &mut self, request: impl tonic::IntoRequest, @@ -153,10 +188,18 @@ pub mod query_server { &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn auction( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; async fn auctions( &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn bid( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; async fn bids( &self, request: tonic::Request, @@ -276,6 +319,44 @@ pub mod query_server { }; Box::pin(fut) } + "/side.auction.Query/Auction" => { + #[allow(non_camel_case_types)] + struct AuctionSvc(pub Arc); + impl tonic::server::UnaryService for AuctionSvc { + type Response = super::QueryAuctionResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).auction(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 = AuctionSvc(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) + } "/side.auction.Query/Auctions" => { #[allow(non_camel_case_types)] struct AuctionsSvc(pub Arc); @@ -314,6 +395,44 @@ pub mod query_server { }; Box::pin(fut) } + "/side.auction.Query/Bid" => { + #[allow(non_camel_case_types)] + struct BidSvc(pub Arc); + impl tonic::server::UnaryService for BidSvc { + type Response = super::QueryBidResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).bid(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 = BidSvc(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) + } "/side.auction.Query/Bids" => { #[allow(non_camel_case_types)] struct BidsSvc(pub Arc); @@ -489,6 +608,42 @@ pub mod msg_client { .insert(GrpcMethod::new("side.auction.Msg", "Bid")); self.inner.unary(req, path, codec).await } + pub async fn cancel_bid( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.auction.Msg/CancelBid"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.auction.Msg", "CancelBid")); + self.inner.unary(req, path, codec).await + } + pub async fn update_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.auction.Msg/UpdateParams"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.auction.Msg", "UpdateParams")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -503,6 +658,14 @@ pub mod msg_server { &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn cancel_bid( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn update_params( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; } #[derive(Debug)] pub struct MsgServer { @@ -615,6 +778,82 @@ pub mod msg_server { }; Box::pin(fut) } + "/side.auction.Msg/CancelBid" => { + #[allow(non_camel_case_types)] + struct CancelBidSvc(pub Arc); + impl tonic::server::UnaryService for CancelBidSvc { + type Response = super::MsgCancelBidResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).cancel_bid(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 = CancelBidSvc(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) + } + "/side.auction.Msg/UpdateParams" => { + #[allow(non_camel_case_types)] + struct UpdateParamsSvc(pub Arc); + impl tonic::server::UnaryService for UpdateParamsSvc { + type Response = super::MsgUpdateParamsResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).update_params(request).await }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UpdateParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => Box::pin(async move { Ok(http::Response::builder() .status(200) diff --git a/side-proto/src/prost/side/side.btcbridge.rs b/side-proto/src/prost/side/side.btcbridge.rs index b7a7297..b188af7 100644 --- a/side-proto/src/prost/side/side.btcbridge.rs +++ b/side-proto/src/prost/side/side.btcbridge.rs @@ -18,29 +18,32 @@ pub struct Params { /// Indicates if withdrawal is enabled #[prost(bool, tag = "5")] pub withdraw_enabled: bool, - /// Trusted relayers for non-btc asset deposit + /// Trusted relayers to submit bitcoin block headers #[prost(string, repeated, tag = "6")] + pub trusted_btc_relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Trusted relayers for non-btc asset deposit + #[prost(string, repeated, tag = "7")] pub trusted_non_btc_relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Trusted oracles for providing offchain data, e.g. bitcoin fee rate - #[prost(string, repeated, tag = "7")] + #[prost(string, repeated, tag = "8")] pub trusted_oracles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Period of validity for the fee rate - #[prost(int64, tag = "8")] + #[prost(int64, tag = "9")] pub fee_rate_validity_period: i64, /// Asset vaults - #[prost(message, repeated, tag = "9")] + #[prost(message, repeated, tag = "10")] pub vaults: ::prost::alloc::vec::Vec, /// Withdrawal params - #[prost(message, optional, tag = "10")] + #[prost(message, optional, tag = "11")] pub withdraw_params: ::core::option::Option, /// Protocol limitations - #[prost(message, optional, tag = "11")] + #[prost(message, optional, tag = "12")] pub protocol_limits: ::core::option::Option, /// Protocol fees - #[prost(message, optional, tag = "12")] + #[prost(message, optional, tag = "13")] pub protocol_fees: ::core::option::Option, /// TSS params - #[prost(message, optional, tag = "13")] + #[prost(message, optional, tag = "14")] pub tss_params: ::core::option::Option, } impl ::prost::Name for Params { @@ -416,9 +419,9 @@ pub struct DkgParticipant { /// the operator address of the corresponding validator #[prost(string, tag = "2")] pub operator_address: ::prost::alloc::string::String, - /// the consensus address of the corresponding validator + /// the consensus public key of the corresponding validator #[prost(string, tag = "3")] - pub consensus_address: ::prost::alloc::string::String, + pub consensus_pubkey: ::prost::alloc::string::String, } impl ::prost::Name for DkgParticipant { const NAME: &'static str = "DKGParticipant"; diff --git a/side-proto/src/prost/side/side.btcbridge.serde.rs b/side-proto/src/prost/side/side.btcbridge.serde.rs index 61569b7..f99b213 100644 --- a/side-proto/src/prost/side/side.btcbridge.serde.rs +++ b/side-proto/src/prost/side/side.btcbridge.serde.rs @@ -669,7 +669,7 @@ impl serde::Serialize for DkgParticipant { if !self.operator_address.is_empty() { len += 1; } - if !self.consensus_address.is_empty() { + if !self.consensus_pubkey.is_empty() { len += 1; } let mut struct_ser = serializer.serialize_struct("side.btcbridge.DKGParticipant", len)?; @@ -679,8 +679,8 @@ impl serde::Serialize for DkgParticipant { if !self.operator_address.is_empty() { struct_ser.serialize_field("operatorAddress", &self.operator_address)?; } - if !self.consensus_address.is_empty() { - struct_ser.serialize_field("consensusAddress", &self.consensus_address)?; + if !self.consensus_pubkey.is_empty() { + struct_ser.serialize_field("consensusPubkey", &self.consensus_pubkey)?; } struct_ser.end() } @@ -696,15 +696,15 @@ impl<'de> serde::Deserialize<'de> for DkgParticipant { "moniker", "operator_address", "operatorAddress", - "consensus_address", - "consensusAddress", + "consensus_pubkey", + "consensusPubkey", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Moniker, OperatorAddress, - ConsensusAddress, + ConsensusPubkey, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -734,8 +734,8 @@ impl<'de> serde::Deserialize<'de> for DkgParticipant { "operatorAddress" | "operator_address" => { Ok(GeneratedField::OperatorAddress) } - "consensusAddress" | "consensus_address" => { - Ok(GeneratedField::ConsensusAddress) + "consensusPubkey" | "consensus_pubkey" => { + Ok(GeneratedField::ConsensusPubkey) } _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -758,7 +758,7 @@ impl<'de> serde::Deserialize<'de> for DkgParticipant { { let mut moniker__ = None; let mut operator_address__ = None; - let mut consensus_address__ = None; + let mut consensus_pubkey__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Moniker => { @@ -773,18 +773,18 @@ impl<'de> serde::Deserialize<'de> for DkgParticipant { } operator_address__ = Some(map_.next_value()?); } - GeneratedField::ConsensusAddress => { - if consensus_address__.is_some() { - return Err(serde::de::Error::duplicate_field("consensusAddress")); + GeneratedField::ConsensusPubkey => { + if consensus_pubkey__.is_some() { + return Err(serde::de::Error::duplicate_field("consensusPubkey")); } - consensus_address__ = Some(map_.next_value()?); + consensus_pubkey__ = Some(map_.next_value()?); } } } Ok(DkgParticipant { moniker: moniker__.unwrap_or_default(), operator_address: operator_address__.unwrap_or_default(), - consensus_address: consensus_address__.unwrap_or_default(), + consensus_pubkey: consensus_pubkey__.unwrap_or_default(), }) } } @@ -4551,6 +4551,9 @@ impl serde::Serialize for Params { if self.withdraw_enabled { len += 1; } + if !self.trusted_btc_relayers.is_empty() { + len += 1; + } if !self.trusted_non_btc_relayers.is_empty() { len += 1; } @@ -4595,6 +4598,9 @@ impl serde::Serialize for Params { if self.withdraw_enabled { struct_ser.serialize_field("withdrawEnabled", &self.withdraw_enabled)?; } + if !self.trusted_btc_relayers.is_empty() { + struct_ser.serialize_field("trustedBtcRelayers", &self.trusted_btc_relayers)?; + } if !self.trusted_non_btc_relayers.is_empty() { struct_ser.serialize_field("trustedNonBtcRelayers", &self.trusted_non_btc_relayers)?; } @@ -4643,6 +4649,8 @@ impl<'de> serde::Deserialize<'de> for Params { "depositEnabled", "withdraw_enabled", "withdrawEnabled", + "trusted_btc_relayers", + "trustedBtcRelayers", "trusted_non_btc_relayers", "trustedNonBtcRelayers", "trusted_oracles", @@ -4667,6 +4675,7 @@ impl<'de> serde::Deserialize<'de> for Params { BtcVoucherDenom, DepositEnabled, WithdrawEnabled, + TrustedBtcRelayers, TrustedNonBtcRelayers, TrustedOracles, FeeRateValidityPeriod, @@ -4713,6 +4722,9 @@ impl<'de> serde::Deserialize<'de> for Params { "withdrawEnabled" | "withdraw_enabled" => { Ok(GeneratedField::WithdrawEnabled) } + "trustedBtcRelayers" | "trusted_btc_relayers" => { + Ok(GeneratedField::TrustedBtcRelayers) + } "trustedNonBtcRelayers" | "trusted_non_btc_relayers" => { Ok(GeneratedField::TrustedNonBtcRelayers) } @@ -4755,6 +4767,7 @@ impl<'de> serde::Deserialize<'de> for Params { let mut btc_voucher_denom__ = None; let mut deposit_enabled__ = None; let mut withdraw_enabled__ = None; + let mut trusted_btc_relayers__ = None; let mut trusted_non_btc_relayers__ = None; let mut trusted_oracles__ = None; let mut fee_rate_validity_period__ = None; @@ -4803,6 +4816,14 @@ impl<'de> serde::Deserialize<'de> for Params { } withdraw_enabled__ = Some(map_.next_value()?); } + GeneratedField::TrustedBtcRelayers => { + if trusted_btc_relayers__.is_some() { + return Err(serde::de::Error::duplicate_field( + "trustedBtcRelayers", + )); + } + trusted_btc_relayers__ = Some(map_.next_value()?); + } GeneratedField::TrustedNonBtcRelayers => { if trusted_non_btc_relayers__.is_some() { return Err(serde::de::Error::duplicate_field( @@ -4866,6 +4887,7 @@ impl<'de> serde::Deserialize<'de> for Params { btc_voucher_denom: btc_voucher_denom__.unwrap_or_default(), deposit_enabled: deposit_enabled__.unwrap_or_default(), withdraw_enabled: withdraw_enabled__.unwrap_or_default(), + trusted_btc_relayers: trusted_btc_relayers__.unwrap_or_default(), trusted_non_btc_relayers: trusted_non_btc_relayers__.unwrap_or_default(), trusted_oracles: trusted_oracles__.unwrap_or_default(), fee_rate_validity_period: fee_rate_validity_period__.unwrap_or_default(), diff --git a/side-proto/src/prost/side/side.dlc.rs b/side-proto/src/prost/side/side.dlc.rs index 78b02e1..b880182 100644 --- a/side-proto/src/prost/side/side.dlc.rs +++ b/side-proto/src/prost/side/side.dlc.rs @@ -2,8 +2,8 @@ #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DlcOracle { - #[prost(uint32, tag = "1")] - pub id: u32, + #[prost(uint64, tag = "1")] + pub id: u64, #[prost(string, tag = "2")] pub desc: ::prost::alloc::string::String, #[prost(string, repeated, tag = "3")] @@ -11,13 +11,11 @@ pub struct DlcOracle { #[prost(uint32, tag = "4")] pub threshold: u32, #[prost(string, tag = "5")] - pub address: ::prost::alloc::string::String, - #[prost(string, tag = "6")] pub pubkey: ::prost::alloc::string::String, + #[prost(uint64, tag = "6")] + pub nonce_index: u64, #[prost(enumeration = "DlcOracleStatus", tag = "7")] pub status: i32, - #[prost(uint64, tag = "8")] - pub nonce_index: u64, } impl ::prost::Name for DlcOracle { const NAME: &'static str = "DLCOracle"; @@ -29,8 +27,8 @@ impl ::prost::Name for DlcOracle { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Agency { - #[prost(uint32, tag = "1")] - pub id: u32, + #[prost(uint64, tag = "1")] + pub id: u64, #[prost(string, tag = "2")] pub desc: ::prost::alloc::string::String, #[prost(string, repeated, tag = "3")] @@ -38,7 +36,7 @@ pub struct Agency { #[prost(uint32, tag = "4")] pub threshold: u32, #[prost(string, tag = "5")] - pub address: ::prost::alloc::string::String, + pub pubkey: ::prost::alloc::string::String, #[prost(enumeration = "AgencyStatus", tag = "6")] pub status: i32, } @@ -73,17 +71,19 @@ impl ::prost::Name for DlcNonce { pub struct DlcPriceEvent { #[prost(uint64, tag = "1")] pub id: u64, - #[prost(uint64, tag = "2")] - pub trigger_price: u64, + #[prost(string, tag = "2")] + pub trigger_price: ::prost::alloc::string::String, #[prost(string, tag = "3")] - pub nonce: ::prost::alloc::string::String, + pub price_decimal: ::prost::alloc::string::String, #[prost(string, tag = "4")] - pub pubkey: ::prost::alloc::string::String, + pub nonce: ::prost::alloc::string::String, #[prost(string, tag = "5")] + pub pubkey: ::prost::alloc::string::String, + #[prost(string, tag = "6")] pub description: ::prost::alloc::string::String, - #[prost(bool, tag = "6")] + #[prost(bool, tag = "7")] pub has_triggered: bool, - #[prost(message, optional, tag = "7")] + #[prost(message, optional, tag = "8")] pub publish_at: ::core::option::Option<::tendermint_proto::google::protobuf::Timestamp>, } impl ::prost::Name for DlcPriceEvent { @@ -96,8 +96,8 @@ impl ::prost::Name for DlcPriceEvent { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DlcAttestation { - #[prost(string, tag = "1")] - pub id: ::prost::alloc::string::String, + #[prost(uint64, tag = "1")] + pub id: u64, #[prost(uint64, tag = "2")] pub event_id: u64, #[prost(message, optional, tag = "3")] @@ -196,7 +196,7 @@ pub struct Params { #[prost(uint32, tag = "1")] pub nonce_queue_size: u32, #[prost(message, repeated, tag = "2")] - pub price_interval: ::prost::alloc::vec::Vec, + pub price_intervals: ::prost::alloc::vec::Vec, } impl ::prost::Name for Params { const NAME: &'static str = "Params"; @@ -212,7 +212,7 @@ pub struct GenesisState { #[prost(message, optional, tag = "1")] pub params: ::core::option::Option, #[prost(message, repeated, tag = "2")] - pub announcements: ::prost::alloc::vec::Vec, + pub events: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag = "3")] pub attestations: ::prost::alloc::vec::Vec, } @@ -225,7 +225,10 @@ impl ::prost::Name for GenesisState { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryAttestationRequest {} +pub struct QueryAttestationRequest { + #[prost(uint64, tag = "1")] + pub id: u64, +} impl ::prost::Name for QueryAttestationRequest { const NAME: &'static str = "QueryAttestationRequest"; const PACKAGE: &'static str = "side.dlc"; @@ -236,8 +239,8 @@ impl ::prost::Name for QueryAttestationRequest { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryAttestationResponse { - #[prost(message, repeated, tag = "1")] - pub attestations: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "1")] + pub attestation: ::core::option::Option, } impl ::prost::Name for QueryAttestationResponse { const NAME: &'static str = "QueryAttestationResponse"; @@ -248,9 +251,40 @@ impl ::prost::Name for QueryAttestationResponse { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAttestationsRequest { + #[prost(message, optional, tag = "1")] + pub pagination: ::core::option::Option, +} +impl ::prost::Name for QueryAttestationsRequest { + const NAME: &'static str = "QueryAttestationsRequest"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryAttestationsResponse { + #[prost(message, repeated, tag = "1")] + pub attestations: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub pagination: + ::core::option::Option, +} +impl ::prost::Name for QueryAttestationsResponse { + const NAME: &'static str = "QueryAttestationsResponse"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryAgenciesRequest { #[prost(enumeration = "AgencyStatus", tag = "1")] pub status: i32, + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option, } impl ::prost::Name for QueryAgenciesRequest { const NAME: &'static str = "QueryAgenciesRequest"; @@ -264,6 +298,9 @@ impl ::prost::Name for QueryAgenciesRequest { pub struct QueryAgenciesResponse { #[prost(message, repeated, tag = "1")] pub agencies: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub pagination: + ::core::option::Option, } impl ::prost::Name for QueryAgenciesResponse { const NAME: &'static str = "QueryAgenciesResponse"; @@ -277,6 +314,8 @@ impl ::prost::Name for QueryAgenciesResponse { pub struct QueryOraclesRequest { #[prost(enumeration = "DlcOracleStatus", tag = "1")] pub status: i32, + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option, } impl ::prost::Name for QueryOraclesRequest { const NAME: &'static str = "QueryOraclesRequest"; @@ -290,6 +329,9 @@ impl ::prost::Name for QueryOraclesRequest { pub struct QueryOraclesResponse { #[prost(message, repeated, tag = "1")] pub oracles: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub pagination: + ::core::option::Option, } impl ::prost::Name for QueryOraclesResponse { const NAME: &'static str = "QueryOraclesResponse"; @@ -309,7 +351,7 @@ impl ::prost::Name for QueryCountNoncesRequest { } } /// QueryCountNoncesResponse is response type for the Query/CountNonces RPC method. -/// counts should use the same order as recommende oracles in Params +/// counts should use the same order as recommended oracles in Params #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryCountNoncesResponse { @@ -326,7 +368,40 @@ impl ::prost::Name for QueryCountNoncesResponse { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryNoncesRequest {} +pub struct QueryNonceRequest { + #[prost(uint64, tag = "1")] + pub oracle_id: u64, + #[prost(uint64, tag = "2")] + pub index: u64, +} +impl ::prost::Name for QueryNonceRequest { + const NAME: &'static str = "QueryNonceRequest"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNonceResponse { + #[prost(message, optional, tag = "1")] + pub nonce: ::core::option::Option, +} +impl ::prost::Name for QueryNonceResponse { + const NAME: &'static str = "QueryNonceResponse"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNoncesRequest { + #[prost(uint64, tag = "1")] + pub oracle_id: u64, + #[prost(message, optional, tag = "2")] + pub pagination: ::core::option::Option, +} impl ::prost::Name for QueryNoncesRequest { const NAME: &'static str = "QueryNoncesRequest"; const PACKAGE: &'static str = "side.dlc"; @@ -340,7 +415,8 @@ pub struct QueryNoncesResponse { #[prost(message, repeated, tag = "1")] pub nonces: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "2")] - pub pagination: ::core::option::Option, + pub pagination: + ::core::option::Option, } impl ::prost::Name for QueryNoncesResponse { const NAME: &'static str = "QueryNoncesResponse"; @@ -349,59 +425,62 @@ impl ::prost::Name for QueryNoncesResponse { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } -/// QueryParamsRequest is request type for the Query/Params RPC method. +/// QueryEventRequest is request type for the Query/Event RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryParamsRequest {} -impl ::prost::Name for QueryParamsRequest { - const NAME: &'static str = "QueryParamsRequest"; +pub struct QueryEventRequest { + #[prost(uint64, tag = "1")] + pub id: u64, +} +impl ::prost::Name for QueryEventRequest { + const NAME: &'static str = "QueryEventRequest"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } -/// QueryParamsResponse is response type for the Query/Params RPC method. +/// QueryEventResponse is response type for the Query/Event RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryParamsResponse { +pub struct QueryEventResponse { #[prost(message, optional, tag = "1")] - pub params: ::core::option::Option, + pub event: ::core::option::Option, } -impl ::prost::Name for QueryParamsResponse { - const NAME: &'static str = "QueryParamsResponse"; +impl ::prost::Name for QueryEventResponse { + const NAME: &'static str = "QueryEventResponse"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } -/// QueryAnnouncementsRequest is request type for the Query/Announcements RPC method. +/// QueryEventsRequest is request type for the Query/Events RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryPriceEventRequest { +pub struct QueryEventsRequest { #[prost(bool, tag = "1")] - pub has_triggered: bool, + pub triggered: bool, #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } -impl ::prost::Name for QueryPriceEventRequest { - const NAME: &'static str = "QueryPriceEventRequest"; +impl ::prost::Name for QueryEventsRequest { + const NAME: &'static str = "QueryEventsRequest"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } -/// QueryAnnouncementsResponse is response type for the Query/Announcements RPC method. +/// QueryEventsResponse is response type for the Query/Events RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryPriceEventResponse { +pub struct QueryEventsResponse { #[prost(message, repeated, tag = "1")] pub events: ::prost::alloc::vec::Vec, #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } -impl ::prost::Name for QueryPriceEventResponse { - const NAME: &'static str = "QueryPriceEventResponse"; +impl ::prost::Name for QueryEventsResponse { + const NAME: &'static str = "QueryEventsResponse"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) @@ -425,8 +504,8 @@ impl ::prost::Name for QueryPriceRequest { #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPriceResponse { - #[prost(uint32, tag = "1")] - pub price: u32, + #[prost(uint64, tag = "1")] + pub price: u64, } impl ::prost::Name for QueryPriceResponse { const NAME: &'static str = "QueryPriceResponse"; @@ -435,20 +514,45 @@ impl ::prost::Name for QueryPriceResponse { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } +/// QueryParamsRequest is request type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest {} +impl ::prost::Name for QueryParamsRequest { + const NAME: &'static str = "QueryParamsRequest"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +/// QueryParamsResponse is response type for the Query/Params RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgSubmitAgencyAddress { +pub struct QueryParamsResponse { + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { + const NAME: &'static str = "QueryParamsResponse"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgSubmitAgencyPubKey { #[prost(string, tag = "1")] - pub id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] pub sender: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub id: u64, #[prost(string, tag = "3")] - pub address: ::prost::alloc::string::String, + pub pub_key: ::prost::alloc::string::String, #[prost(string, tag = "4")] pub signature: ::prost::alloc::string::String, } -impl ::prost::Name for MsgSubmitAgencyAddress { - const NAME: &'static str = "MsgSubmitAgencyAddress"; +impl ::prost::Name for MsgSubmitAgencyPubKey { + const NAME: &'static str = "MsgSubmitAgencyPubKey"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) @@ -456,9 +560,9 @@ impl ::prost::Name for MsgSubmitAgencyAddress { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgSubmitAgencyAddressResponse {} -impl ::prost::Name for MsgSubmitAgencyAddressResponse { - const NAME: &'static str = "MsgSubmitAgencyAddressResponse"; +pub struct MsgSubmitAgencyPubKeyResponse {} +impl ::prost::Name for MsgSubmitAgencyPubKeyResponse { + const NAME: &'static str = "MsgSubmitAgencyPubKeyResponse"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) @@ -466,18 +570,18 @@ impl ::prost::Name for MsgSubmitAgencyAddressResponse { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgSubmitOraclePubkey { +pub struct MsgSubmitOraclePubKey { #[prost(string, tag = "1")] - pub oracle_id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] pub sender: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub oracle_id: u64, #[prost(string, tag = "3")] - pub pubkey: ::prost::alloc::string::String, + pub pub_key: ::prost::alloc::string::String, #[prost(string, tag = "4")] pub signature: ::prost::alloc::string::String, } -impl ::prost::Name for MsgSubmitOraclePubkey { - const NAME: &'static str = "MsgSubmitOraclePubkey"; +impl ::prost::Name for MsgSubmitOraclePubKey { + const NAME: &'static str = "MsgSubmitOraclePubKey"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) @@ -485,9 +589,9 @@ impl ::prost::Name for MsgSubmitOraclePubkey { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct MsgSubmitOraclePubkeyResponse {} -impl ::prost::Name for MsgSubmitOraclePubkeyResponse { - const NAME: &'static str = "MsgSubmitOraclePubkeyResponse"; +pub struct MsgSubmitOraclePubKeyResponse {} +impl ::prost::Name for MsgSubmitOraclePubKeyResponse { + const NAME: &'static str = "MsgSubmitOraclePubKeyResponse"; const PACKAGE: &'static str = "side.dlc"; fn full_name() -> ::prost::alloc::string::String { ::prost::alloc::format!("side.dlc.{}", Self::NAME) @@ -520,24 +624,13 @@ impl ::prost::Name for MsgSubmitNonceResponse { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } -// message MsgSubmitAnnouncementNonce { -// option (cosmos.msg.v1.signer) = "sender"; - -// string sender = 1; -// uint64 announcement_id = 2; -// string nonce = 3; -// string signature = 4; -// } - -// message MsgSubmitAnnouncementNonceResponse {} - #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgSubmitAttestation { #[prost(string, tag = "1")] pub sender: ::prost::alloc::string::String, #[prost(uint64, tag = "2")] - pub announcement_id: u64, + pub event_id: u64, #[prost(string, tag = "3")] pub signature: ::prost::alloc::string::String, } @@ -558,6 +651,97 @@ impl ::prost::Name for MsgSubmitAttestationResponse { ::prost::alloc::format!("side.dlc.{}", Self::NAME) } } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateOracle { + /// authority is the address that controls the module (defaults to x/gov unless overwritten). + #[prost(string, tag = "1")] + pub authority: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "2")] + pub participants: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(uint32, tag = "3")] + pub threshold: u32, +} +impl ::prost::Name for MsgCreateOracle { + const NAME: &'static str = "MsgCreateOracle"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateOracleResponse {} +impl ::prost::Name for MsgCreateOracleResponse { + const NAME: &'static str = "MsgCreateOracleResponse"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateAgency { + /// authority is the address that controls the module (defaults to x/gov unless overwritten). + #[prost(string, tag = "1")] + pub authority: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "2")] + pub participants: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(uint32, tag = "3")] + pub threshold: u32, +} +impl ::prost::Name for MsgCreateAgency { + const NAME: &'static str = "MsgCreateAgency"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateAgencyResponse {} +impl ::prost::Name for MsgCreateAgencyResponse { + const NAME: &'static str = "MsgCreateAgencyResponse"; + const PACKAGE: &'static str = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +/// MsgUpdateParams is the Msg/UpdateParams request type. +/// +/// Since: cosmos-sdk 0.47 +#[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 x/dlc parameters to be updated. + /// + /// 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 = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} +/// MsgUpdateParamsResponse defines the Msg/UpdateParams response type. +/// +/// Since: cosmos-sdk 0.47 +#[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 = "side.dlc"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.dlc.{}", Self::NAME) + } +} include!("side.dlc.serde.rs"); include!("side.dlc.tonic.rs"); // @@protoc_insertion_point(module) diff --git a/side-proto/src/prost/side/side.dlc.serde.rs b/side-proto/src/prost/side/side.dlc.serde.rs index ae7cc25..df9ccfb 100644 --- a/side-proto/src/prost/side/side.dlc.serde.rs +++ b/side-proto/src/prost/side/side.dlc.serde.rs @@ -20,7 +20,7 @@ impl serde::Serialize for Agency { if self.threshold != 0 { len += 1; } - if !self.address.is_empty() { + if !self.pubkey.is_empty() { len += 1; } if self.status != 0 { @@ -28,7 +28,9 @@ impl serde::Serialize for Agency { } let mut struct_ser = serializer.serialize_struct("side.dlc.Agency", len)?; if self.id != 0 { - struct_ser.serialize_field("id", &self.id)?; + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; } if !self.desc.is_empty() { struct_ser.serialize_field("desc", &self.desc)?; @@ -39,8 +41,8 @@ impl serde::Serialize for Agency { if self.threshold != 0 { struct_ser.serialize_field("threshold", &self.threshold)?; } - if !self.address.is_empty() { - struct_ser.serialize_field("address", &self.address)?; + if !self.pubkey.is_empty() { + struct_ser.serialize_field("pubkey", &self.pubkey)?; } if self.status != 0 { let v = AgencyStatus::try_from(self.status).map_err(|_| { @@ -63,7 +65,7 @@ impl<'de> serde::Deserialize<'de> for Agency { "desc", "participants", "threshold", - "address", + "pubkey", "status", ]; @@ -73,7 +75,7 @@ impl<'de> serde::Deserialize<'de> for Agency { Desc, Participants, Threshold, - Address, + Pubkey, Status, } #[cfg(feature = "serde")] @@ -104,7 +106,7 @@ impl<'de> serde::Deserialize<'de> for Agency { "desc" => Ok(GeneratedField::Desc), "participants" => Ok(GeneratedField::Participants), "threshold" => Ok(GeneratedField::Threshold), - "address" => Ok(GeneratedField::Address), + "pubkey" => Ok(GeneratedField::Pubkey), "status" => Ok(GeneratedField::Status), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -129,7 +131,7 @@ impl<'de> serde::Deserialize<'de> for Agency { let mut desc__ = None; let mut participants__ = None; let mut threshold__ = None; - let mut address__ = None; + let mut pubkey__ = None; let mut status__ = None; while let Some(k) = map_.next_key()? { match k { @@ -163,11 +165,11 @@ impl<'de> serde::Deserialize<'de> for Agency { .0, ); } - GeneratedField::Address => { - if address__.is_some() { - return Err(serde::de::Error::duplicate_field("address")); + GeneratedField::Pubkey => { + if pubkey__.is_some() { + return Err(serde::de::Error::duplicate_field("pubkey")); } - address__ = Some(map_.next_value()?); + pubkey__ = Some(map_.next_value()?); } GeneratedField::Status => { if status__.is_some() { @@ -182,7 +184,7 @@ impl<'de> serde::Deserialize<'de> for Agency { desc: desc__.unwrap_or_default(), participants: participants__.unwrap_or_default(), threshold: threshold__.unwrap_or_default(), - address: address__.unwrap_or_default(), + pubkey: pubkey__.unwrap_or_default(), status: status__.unwrap_or_default(), }) } @@ -275,7 +277,7 @@ impl serde::Serialize for DlcAttestation { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { + if self.id != 0 { len += 1; } if self.event_id != 0 { @@ -294,8 +296,10 @@ impl serde::Serialize for DlcAttestation { len += 1; } let mut struct_ser = serializer.serialize_struct("side.dlc.DLCAttestation", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; } if self.event_id != 0 { #[allow(clippy::needless_borrow)] @@ -406,7 +410,10 @@ impl<'de> serde::Deserialize<'de> for DlcAttestation { if id__.is_some() { return Err(serde::de::Error::duplicate_field("id")); } - id__ = Some(map_.next_value()?); + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); } GeneratedField::EventId => { if event_id__.is_some() { @@ -627,21 +634,20 @@ impl serde::Serialize for DlcOracle { if self.threshold != 0 { len += 1; } - if !self.address.is_empty() { - len += 1; - } if !self.pubkey.is_empty() { len += 1; } - if self.status != 0 { + if self.nonce_index != 0 { len += 1; } - if self.nonce_index != 0 { + if self.status != 0 { len += 1; } let mut struct_ser = serializer.serialize_struct("side.dlc.DLCOracle", len)?; if self.id != 0 { - struct_ser.serialize_field("id", &self.id)?; + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; } if !self.desc.is_empty() { struct_ser.serialize_field("desc", &self.desc)?; @@ -652,18 +658,9 @@ impl serde::Serialize for DlcOracle { if self.threshold != 0 { struct_ser.serialize_field("threshold", &self.threshold)?; } - if !self.address.is_empty() { - struct_ser.serialize_field("address", &self.address)?; - } if !self.pubkey.is_empty() { struct_ser.serialize_field("pubkey", &self.pubkey)?; } - if self.status != 0 { - let v = DlcOracleStatus::try_from(self.status).map_err(|_| { - serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) - })?; - struct_ser.serialize_field("status", &v)?; - } if self.nonce_index != 0 { #[allow(clippy::needless_borrow)] struct_ser.serialize_field( @@ -671,6 +668,12 @@ impl serde::Serialize for DlcOracle { alloc::string::ToString::to_string(&self.nonce_index).as_str(), )?; } + if self.status != 0 { + let v = DlcOracleStatus::try_from(self.status).map_err(|_| { + serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) + })?; + struct_ser.serialize_field("status", &v)?; + } struct_ser.end() } } @@ -686,11 +689,10 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { "desc", "participants", "threshold", - "address", "pubkey", - "status", "nonce_index", "nonceIndex", + "status", ]; #[allow(clippy::enum_variant_names)] @@ -699,10 +701,9 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { Desc, Participants, Threshold, - Address, Pubkey, - Status, NonceIndex, + Status, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -732,10 +733,9 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { "desc" => Ok(GeneratedField::Desc), "participants" => Ok(GeneratedField::Participants), "threshold" => Ok(GeneratedField::Threshold), - "address" => Ok(GeneratedField::Address), "pubkey" => Ok(GeneratedField::Pubkey), - "status" => Ok(GeneratedField::Status), "nonceIndex" | "nonce_index" => Ok(GeneratedField::NonceIndex), + "status" => Ok(GeneratedField::Status), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -759,10 +759,9 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { let mut desc__ = None; let mut participants__ = None; let mut threshold__ = None; - let mut address__ = None; let mut pubkey__ = None; - let mut status__ = None; let mut nonce_index__ = None; + let mut status__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Id => { @@ -795,24 +794,12 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { .0, ); } - GeneratedField::Address => { - if address__.is_some() { - return Err(serde::de::Error::duplicate_field("address")); - } - address__ = Some(map_.next_value()?); - } GeneratedField::Pubkey => { if pubkey__.is_some() { return Err(serde::de::Error::duplicate_field("pubkey")); } pubkey__ = Some(map_.next_value()?); } - GeneratedField::Status => { - if status__.is_some() { - return Err(serde::de::Error::duplicate_field("status")); - } - status__ = Some(map_.next_value::()? as i32); - } GeneratedField::NonceIndex => { if nonce_index__.is_some() { return Err(serde::de::Error::duplicate_field("nonceIndex")); @@ -822,6 +809,12 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { .0, ); } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } } } Ok(DlcOracle { @@ -829,10 +822,9 @@ impl<'de> serde::Deserialize<'de> for DlcOracle { desc: desc__.unwrap_or_default(), participants: participants__.unwrap_or_default(), threshold: threshold__.unwrap_or_default(), - address: address__.unwrap_or_default(), pubkey: pubkey__.unwrap_or_default(), - status: status__.unwrap_or_default(), nonce_index: nonce_index__.unwrap_or_default(), + status: status__.unwrap_or_default(), }) } } @@ -927,7 +919,10 @@ impl serde::Serialize for DlcPriceEvent { if self.id != 0 { len += 1; } - if self.trigger_price != 0 { + if !self.trigger_price.is_empty() { + len += 1; + } + if !self.price_decimal.is_empty() { len += 1; } if !self.nonce.is_empty() { @@ -951,12 +946,11 @@ impl serde::Serialize for DlcPriceEvent { struct_ser .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; } - if self.trigger_price != 0 { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field( - "triggerPrice", - alloc::string::ToString::to_string(&self.trigger_price).as_str(), - )?; + if !self.trigger_price.is_empty() { + struct_ser.serialize_field("triggerPrice", &self.trigger_price)?; + } + if !self.price_decimal.is_empty() { + struct_ser.serialize_field("priceDecimal", &self.price_decimal)?; } if !self.nonce.is_empty() { struct_ser.serialize_field("nonce", &self.nonce)?; @@ -987,6 +981,8 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { "id", "trigger_price", "triggerPrice", + "price_decimal", + "priceDecimal", "nonce", "pubkey", "description", @@ -1000,6 +996,7 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { enum GeneratedField { Id, TriggerPrice, + PriceDecimal, Nonce, Pubkey, Description, @@ -1032,6 +1029,7 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { match value { "id" => Ok(GeneratedField::Id), "triggerPrice" | "trigger_price" => Ok(GeneratedField::TriggerPrice), + "priceDecimal" | "price_decimal" => Ok(GeneratedField::PriceDecimal), "nonce" => Ok(GeneratedField::Nonce), "pubkey" => Ok(GeneratedField::Pubkey), "description" => Ok(GeneratedField::Description), @@ -1058,6 +1056,7 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { { let mut id__ = None; let mut trigger_price__ = None; + let mut price_decimal__ = None; let mut nonce__ = None; let mut pubkey__ = None; let mut description__ = None; @@ -1078,10 +1077,13 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { if trigger_price__.is_some() { return Err(serde::de::Error::duplicate_field("triggerPrice")); } - trigger_price__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); + trigger_price__ = Some(map_.next_value()?); + } + GeneratedField::PriceDecimal => { + if price_decimal__.is_some() { + return Err(serde::de::Error::duplicate_field("priceDecimal")); + } + price_decimal__ = Some(map_.next_value()?); } GeneratedField::Nonce => { if nonce__.is_some() { @@ -1118,6 +1120,7 @@ impl<'de> serde::Deserialize<'de> for DlcPriceEvent { Ok(DlcPriceEvent { id: id__.unwrap_or_default(), trigger_price: trigger_price__.unwrap_or_default(), + price_decimal: price_decimal__.unwrap_or_default(), nonce: nonce__.unwrap_or_default(), pubkey: pubkey__.unwrap_or_default(), description: description__.unwrap_or_default(), @@ -1141,7 +1144,7 @@ impl serde::Serialize for GenesisState { if self.params.is_some() { len += 1; } - if !self.announcements.is_empty() { + if !self.events.is_empty() { len += 1; } if !self.attestations.is_empty() { @@ -1151,8 +1154,8 @@ impl serde::Serialize for GenesisState { if let Some(v) = self.params.as_ref() { struct_ser.serialize_field("params", v)?; } - if !self.announcements.is_empty() { - struct_ser.serialize_field("announcements", &self.announcements)?; + if !self.events.is_empty() { + struct_ser.serialize_field("events", &self.events)?; } if !self.attestations.is_empty() { struct_ser.serialize_field("attestations", &self.attestations)?; @@ -1167,12 +1170,12 @@ impl<'de> serde::Deserialize<'de> for GenesisState { where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["params", "announcements", "attestations"]; + const FIELDS: &[&str] = &["params", "events", "attestations"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Params, - Announcements, + Events, Attestations, } #[cfg(feature = "serde")] @@ -1200,7 +1203,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { { match value { "params" => Ok(GeneratedField::Params), - "announcements" => Ok(GeneratedField::Announcements), + "events" => Ok(GeneratedField::Events), "attestations" => Ok(GeneratedField::Attestations), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -1222,7 +1225,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { V: serde::de::MapAccess<'de>, { let mut params__ = None; - let mut announcements__ = None; + let mut events__ = None; let mut attestations__ = None; while let Some(k) = map_.next_key()? { match k { @@ -1232,11 +1235,11 @@ impl<'de> serde::Deserialize<'de> for GenesisState { } params__ = map_.next_value()?; } - GeneratedField::Announcements => { - if announcements__.is_some() { - return Err(serde::de::Error::duplicate_field("announcements")); + GeneratedField::Events => { + if events__.is_some() { + return Err(serde::de::Error::duplicate_field("events")); } - announcements__ = Some(map_.next_value()?); + events__ = Some(map_.next_value()?); } GeneratedField::Attestations => { if attestations__.is_some() { @@ -1248,7 +1251,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { } Ok(GenesisState { params: params__, - announcements: announcements__.unwrap_or_default(), + events: events__.unwrap_or_default(), attestations: attestations__.unwrap_or_default(), }) } @@ -1257,7 +1260,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState { } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitAgencyAddress { +impl serde::Serialize for MsgCreateAgency { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1265,49 +1268,42 @@ impl serde::Serialize for MsgSubmitAgencyAddress { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.id.is_empty() { + if !self.authority.is_empty() { len += 1; } - if !self.sender.is_empty() { - len += 1; - } - if !self.address.is_empty() { + if !self.participants.is_empty() { len += 1; } - if !self.signature.is_empty() { + if self.threshold != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitAgencyAddress", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; - } - if !self.sender.is_empty() { - struct_ser.serialize_field("sender", &self.sender)?; + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgCreateAgency", len)?; + if !self.authority.is_empty() { + struct_ser.serialize_field("authority", &self.authority)?; } - if !self.address.is_empty() { - struct_ser.serialize_field("address", &self.address)?; + if !self.participants.is_empty() { + struct_ser.serialize_field("participants", &self.participants)?; } - if !self.signature.is_empty() { - struct_ser.serialize_field("signature", &self.signature)?; + if self.threshold != 0 { + struct_ser.serialize_field("threshold", &self.threshold)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyAddress { +impl<'de> serde::Deserialize<'de> for MsgCreateAgency { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["id", "sender", "address", "signature"]; + const FIELDS: &[&str] = &["authority", "participants", "threshold"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Id, - Sender, - Address, - Signature, + Authority, + Participants, + Threshold, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -1333,10 +1329,9 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyAddress { E: serde::de::Error, { match value { - "id" => Ok(GeneratedField::Id), - "sender" => Ok(GeneratedField::Sender), - "address" => Ok(GeneratedField::Address), - "signature" => Ok(GeneratedField::Signature), + "authority" => Ok(GeneratedField::Authority), + "participants" => Ok(GeneratedField::Participants), + "threshold" => Ok(GeneratedField::Threshold), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1346,64 +1341,56 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyAddress { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitAgencyAddress; + type Value = MsgCreateAgency; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitAgencyAddress") + formatter.write_str("struct side.dlc.MsgCreateAgency") } - 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 id__ = None; - let mut sender__ = None; - let mut address__ = None; - let mut signature__ = None; + let mut authority__ = None; + let mut participants__ = None; + let mut threshold__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); + GeneratedField::Authority => { + if authority__.is_some() { + return Err(serde::de::Error::duplicate_field("authority")); } - id__ = Some(map_.next_value()?); + authority__ = Some(map_.next_value()?); } - GeneratedField::Sender => { - if sender__.is_some() { - return Err(serde::de::Error::duplicate_field("sender")); - } - sender__ = Some(map_.next_value()?); - } - GeneratedField::Address => { - if address__.is_some() { - return Err(serde::de::Error::duplicate_field("address")); + GeneratedField::Participants => { + if participants__.is_some() { + return Err(serde::de::Error::duplicate_field("participants")); } - address__ = Some(map_.next_value()?); + participants__ = Some(map_.next_value()?); } - GeneratedField::Signature => { - if signature__.is_some() { - return Err(serde::de::Error::duplicate_field("signature")); + GeneratedField::Threshold => { + if threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("threshold")); } - signature__ = Some(map_.next_value()?); + threshold__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); } } } - Ok(MsgSubmitAgencyAddress { - id: id__.unwrap_or_default(), - sender: sender__.unwrap_or_default(), - address: address__.unwrap_or_default(), - signature: signature__.unwrap_or_default(), + Ok(MsgCreateAgency { + authority: authority__.unwrap_or_default(), + participants: participants__.unwrap_or_default(), + threshold: threshold__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.MsgSubmitAgencyAddress", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgCreateAgency", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitAgencyAddressResponse { +impl serde::Serialize for MsgCreateAgencyResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1411,13 +1398,12 @@ impl serde::Serialize for MsgSubmitAgencyAddressResponse { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = - serializer.serialize_struct("side.dlc.MsgSubmitAgencyAddressResponse", len)?; + let struct_ser = serializer.serialize_struct("side.dlc.MsgCreateAgencyResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyAddressResponse { +impl<'de> serde::Deserialize<'de> for MsgCreateAgencyResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -1458,34 +1444,34 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyAddressResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitAgencyAddressResponse; + type Value = MsgCreateAgencyResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitAgencyAddressResponse") + formatter.write_str("struct side.dlc.MsgCreateAgencyResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(MsgSubmitAgencyAddressResponse {}) + Ok(MsgCreateAgencyResponse {}) } } deserializer.deserialize_struct( - "side.dlc.MsgSubmitAgencyAddressResponse", + "side.dlc.MsgCreateAgencyResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitAttestation { +impl serde::Serialize for MsgCreateOracle { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1493,46 +1479,42 @@ impl serde::Serialize for MsgSubmitAttestation { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.sender.is_empty() { + if !self.authority.is_empty() { len += 1; } - if self.announcement_id != 0 { + if !self.participants.is_empty() { len += 1; } - if !self.signature.is_empty() { + if self.threshold != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitAttestation", len)?; - if !self.sender.is_empty() { - struct_ser.serialize_field("sender", &self.sender)?; + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgCreateOracle", len)?; + if !self.authority.is_empty() { + struct_ser.serialize_field("authority", &self.authority)?; } - if self.announcement_id != 0 { - #[allow(clippy::needless_borrow)] - struct_ser.serialize_field( - "announcementId", - alloc::string::ToString::to_string(&self.announcement_id).as_str(), - )?; + if !self.participants.is_empty() { + struct_ser.serialize_field("participants", &self.participants)?; } - if !self.signature.is_empty() { - struct_ser.serialize_field("signature", &self.signature)?; + if self.threshold != 0 { + struct_ser.serialize_field("threshold", &self.threshold)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitAttestation { +impl<'de> serde::Deserialize<'de> for MsgCreateOracle { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["sender", "announcement_id", "announcementId", "signature"]; + const FIELDS: &[&str] = &["authority", "participants", "threshold"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Sender, - AnnouncementId, - Signature, + Authority, + Participants, + Threshold, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -1558,11 +1540,9 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAttestation { E: serde::de::Error, { match value { - "sender" => Ok(GeneratedField::Sender), - "announcementId" | "announcement_id" => { - Ok(GeneratedField::AnnouncementId) - } - "signature" => Ok(GeneratedField::Signature), + "authority" => Ok(GeneratedField::Authority), + "participants" => Ok(GeneratedField::Participants), + "threshold" => Ok(GeneratedField::Threshold), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1572,59 +1552,56 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAttestation { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitAttestation; + type Value = MsgCreateOracle; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitAttestation") + formatter.write_str("struct side.dlc.MsgCreateOracle") } - 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 sender__ = None; - let mut announcement_id__ = None; - let mut signature__ = None; + let mut authority__ = None; + let mut participants__ = None; + let mut threshold__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Sender => { - if sender__.is_some() { - return Err(serde::de::Error::duplicate_field("sender")); + GeneratedField::Authority => { + if authority__.is_some() { + return Err(serde::de::Error::duplicate_field("authority")); } - sender__ = Some(map_.next_value()?); + authority__ = Some(map_.next_value()?); + } + GeneratedField::Participants => { + if participants__.is_some() { + return Err(serde::de::Error::duplicate_field("participants")); + } + participants__ = Some(map_.next_value()?); } - GeneratedField::AnnouncementId => { - if announcement_id__.is_some() { - return Err(serde::de::Error::duplicate_field("announcementId")); + GeneratedField::Threshold => { + if threshold__.is_some() { + return Err(serde::de::Error::duplicate_field("threshold")); } - announcement_id__ = Some( + threshold__ = Some( map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? .0, ); } - GeneratedField::Signature => { - if signature__.is_some() { - return Err(serde::de::Error::duplicate_field("signature")); - } - signature__ = Some(map_.next_value()?); - } } } - Ok(MsgSubmitAttestation { - sender: sender__.unwrap_or_default(), - announcement_id: announcement_id__.unwrap_or_default(), - signature: signature__.unwrap_or_default(), + Ok(MsgCreateOracle { + authority: authority__.unwrap_or_default(), + participants: participants__.unwrap_or_default(), + threshold: threshold__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.MsgSubmitAttestation", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgCreateOracle", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitAttestationResponse { +impl serde::Serialize for MsgCreateOracleResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1632,13 +1609,12 @@ impl serde::Serialize for MsgSubmitAttestationResponse { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = - serializer.serialize_struct("side.dlc.MsgSubmitAttestationResponse", len)?; + let struct_ser = serializer.serialize_struct("side.dlc.MsgCreateOracleResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitAttestationResponse { +impl<'de> serde::Deserialize<'de> for MsgCreateOracleResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -1679,34 +1655,34 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitAttestationResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitAttestationResponse; + type Value = MsgCreateOracleResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitAttestationResponse") + formatter.write_str("struct side.dlc.MsgCreateOracleResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(MsgSubmitAttestationResponse {}) + Ok(MsgCreateOracleResponse {}) } } deserializer.deserialize_struct( - "side.dlc.MsgSubmitAttestationResponse", + "side.dlc.MsgCreateOracleResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitNonce { +impl serde::Serialize for MsgSubmitAgencyPubKey { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1717,18 +1693,26 @@ impl serde::Serialize for MsgSubmitNonce { if !self.sender.is_empty() { len += 1; } - if !self.nonce.is_empty() { + if self.id != 0 { + len += 1; + } + if !self.pub_key.is_empty() { len += 1; } if !self.signature.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitNonce", len)?; + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitAgencyPubKey", len)?; if !self.sender.is_empty() { struct_ser.serialize_field("sender", &self.sender)?; } - if !self.nonce.is_empty() { - struct_ser.serialize_field("nonce", &self.nonce)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + if !self.pub_key.is_empty() { + struct_ser.serialize_field("pubKey", &self.pub_key)?; } if !self.signature.is_empty() { struct_ser.serialize_field("signature", &self.signature)?; @@ -1737,18 +1721,19 @@ impl serde::Serialize for MsgSubmitNonce { } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { +impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyPubKey { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["sender", "nonce", "signature"]; + const FIELDS: &[&str] = &["sender", "id", "pub_key", "pubKey", "signature"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Sender, - Nonce, + Id, + PubKey, Signature, } #[cfg(feature = "serde")] @@ -1776,7 +1761,8 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { { match value { "sender" => Ok(GeneratedField::Sender), - "nonce" => Ok(GeneratedField::Nonce), + "id" => Ok(GeneratedField::Id), + "pubKey" | "pub_key" => Ok(GeneratedField::PubKey), "signature" => Ok(GeneratedField::Signature), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -1787,18 +1773,22 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitNonce; + type Value = MsgSubmitAgencyPubKey; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitNonce") + formatter.write_str("struct side.dlc.MsgSubmitAgencyPubKey") } - 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 sender__ = None; - let mut nonce__ = None; + let mut id__ = None; + let mut pub_key__ = None; let mut signature__ = None; while let Some(k) = map_.next_key()? { match k { @@ -1808,11 +1798,20 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { } sender__ = Some(map_.next_value()?); } - GeneratedField::Nonce => { - if nonce__.is_some() { - return Err(serde::de::Error::duplicate_field("nonce")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - nonce__ = Some(map_.next_value()?); + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::PubKey => { + if pub_key__.is_some() { + return Err(serde::de::Error::duplicate_field("pubKey")); + } + pub_key__ = Some(map_.next_value()?); } GeneratedField::Signature => { if signature__.is_some() { @@ -1822,18 +1821,19 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { } } } - Ok(MsgSubmitNonce { + Ok(MsgSubmitAgencyPubKey { sender: sender__.unwrap_or_default(), - nonce: nonce__.unwrap_or_default(), + id: id__.unwrap_or_default(), + pub_key: pub_key__.unwrap_or_default(), signature: signature__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.MsgSubmitNonce", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgSubmitAgencyPubKey", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitNonceResponse { +impl serde::Serialize for MsgSubmitAgencyPubKeyResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1841,12 +1841,13 @@ impl serde::Serialize for MsgSubmitNonceResponse { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitNonceResponse", len)?; + let struct_ser = + serializer.serialize_struct("side.dlc.MsgSubmitAgencyPubKeyResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitNonceResponse { +impl<'de> serde::Deserialize<'de> for MsgSubmitAgencyPubKeyResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -1887,30 +1888,34 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitNonceResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitNonceResponse; + type Value = MsgSubmitAgencyPubKeyResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitNonceResponse") + formatter.write_str("struct side.dlc.MsgSubmitAgencyPubKeyResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(MsgSubmitNonceResponse {}) + Ok(MsgSubmitAgencyPubKeyResponse {}) } } - deserializer.deserialize_struct("side.dlc.MsgSubmitNonceResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct( + "side.dlc.MsgSubmitAgencyPubKeyResponse", + FIELDS, + GeneratedVisitor, + ) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitOraclePubkey { +impl serde::Serialize for MsgSubmitAttestation { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -1918,27 +1923,25 @@ impl serde::Serialize for MsgSubmitOraclePubkey { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.oracle_id.is_empty() { - len += 1; - } if !self.sender.is_empty() { len += 1; } - if !self.pubkey.is_empty() { + if self.event_id != 0 { len += 1; } if !self.signature.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitOraclePubkey", len)?; - if !self.oracle_id.is_empty() { - struct_ser.serialize_field("oracleId", &self.oracle_id)?; - } + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitAttestation", len)?; if !self.sender.is_empty() { struct_ser.serialize_field("sender", &self.sender)?; } - if !self.pubkey.is_empty() { - struct_ser.serialize_field("pubkey", &self.pubkey)?; + if self.event_id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "eventId", + alloc::string::ToString::to_string(&self.event_id).as_str(), + )?; } if !self.signature.is_empty() { struct_ser.serialize_field("signature", &self.signature)?; @@ -1947,19 +1950,18 @@ impl serde::Serialize for MsgSubmitOraclePubkey { } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkey { +impl<'de> serde::Deserialize<'de> for MsgSubmitAttestation { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["oracle_id", "oracleId", "sender", "pubkey", "signature"]; + const FIELDS: &[&str] = &["sender", "event_id", "eventId", "signature"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - OracleId, Sender, - Pubkey, + EventId, Signature, } #[cfg(feature = "serde")] @@ -1986,9 +1988,8 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkey { E: serde::de::Error, { match value { - "oracleId" | "oracle_id" => Ok(GeneratedField::OracleId), "sender" => Ok(GeneratedField::Sender), - "pubkey" => Ok(GeneratedField::Pubkey), + "eventId" | "event_id" => Ok(GeneratedField::EventId), "signature" => Ok(GeneratedField::Signature), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -1999,42 +2000,38 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkey { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitOraclePubkey; + type Value = MsgSubmitAttestation; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitOraclePubkey") + formatter.write_str("struct side.dlc.MsgSubmitAttestation") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut oracle_id__ = None; let mut sender__ = None; - let mut pubkey__ = None; + let mut event_id__ = None; let mut signature__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::OracleId => { - if oracle_id__.is_some() { - return Err(serde::de::Error::duplicate_field("oracleId")); - } - oracle_id__ = Some(map_.next_value()?); - } GeneratedField::Sender => { if sender__.is_some() { return Err(serde::de::Error::duplicate_field("sender")); } sender__ = Some(map_.next_value()?); } - GeneratedField::Pubkey => { - if pubkey__.is_some() { - return Err(serde::de::Error::duplicate_field("pubkey")); + GeneratedField::EventId => { + if event_id__.is_some() { + return Err(serde::de::Error::duplicate_field("eventId")); } - pubkey__ = Some(map_.next_value()?); + event_id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); } GeneratedField::Signature => { if signature__.is_some() { @@ -2044,19 +2041,18 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkey { } } } - Ok(MsgSubmitOraclePubkey { - oracle_id: oracle_id__.unwrap_or_default(), + Ok(MsgSubmitAttestation { sender: sender__.unwrap_or_default(), - pubkey: pubkey__.unwrap_or_default(), + event_id: event_id__.unwrap_or_default(), signature: signature__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.MsgSubmitOraclePubkey", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgSubmitAttestation", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for MsgSubmitOraclePubkeyResponse { +impl serde::Serialize for MsgSubmitAttestationResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2065,12 +2061,12 @@ impl serde::Serialize for MsgSubmitOraclePubkeyResponse { use serde::ser::SerializeStruct; let len = 0; let struct_ser = - serializer.serialize_struct("side.dlc.MsgSubmitOraclePubkeyResponse", len)?; + serializer.serialize_struct("side.dlc.MsgSubmitAttestationResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkeyResponse { +impl<'de> serde::Deserialize<'de> for MsgSubmitAttestationResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -2111,34 +2107,34 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubkeyResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MsgSubmitOraclePubkeyResponse; + type Value = MsgSubmitAttestationResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.MsgSubmitOraclePubkeyResponse") + formatter.write_str("struct side.dlc.MsgSubmitAttestationResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(MsgSubmitOraclePubkeyResponse {}) + Ok(MsgSubmitAttestationResponse {}) } } deserializer.deserialize_struct( - "side.dlc.MsgSubmitOraclePubkeyResponse", + "side.dlc.MsgSubmitAttestationResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] -impl serde::Serialize for Params { +impl serde::Serialize for MsgSubmitNonce { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2146,40 +2142,42 @@ impl serde::Serialize for Params { { use serde::ser::SerializeStruct; let mut len = 0; - if self.nonce_queue_size != 0 { + if !self.sender.is_empty() { len += 1; } - if !self.price_interval.is_empty() { + if !self.nonce.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.Params", len)?; - if self.nonce_queue_size != 0 { - struct_ser.serialize_field("nonceQueueSize", &self.nonce_queue_size)?; + if !self.signature.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitNonce", len)?; + if !self.sender.is_empty() { + struct_ser.serialize_field("sender", &self.sender)?; + } + if !self.nonce.is_empty() { + struct_ser.serialize_field("nonce", &self.nonce)?; } - if !self.price_interval.is_empty() { - struct_ser.serialize_field("priceInterval", &self.price_interval)?; + if !self.signature.is_empty() { + struct_ser.serialize_field("signature", &self.signature)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for Params { +impl<'de> serde::Deserialize<'de> for MsgSubmitNonce { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &[ - "nonce_queue_size", - "nonceQueueSize", - "price_interval", - "priceInterval", - ]; + const FIELDS: &[&str] = &["sender", "nonce", "signature"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - NonceQueueSize, - PriceInterval, + Sender, + Nonce, + Signature, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2205,10 +2203,9 @@ impl<'de> serde::Deserialize<'de> for Params { E: serde::de::Error, { match value { - "nonceQueueSize" | "nonce_queue_size" => { - Ok(GeneratedField::NonceQueueSize) - } - "priceInterval" | "price_interval" => Ok(GeneratedField::PriceInterval), + "sender" => Ok(GeneratedField::Sender), + "nonce" => Ok(GeneratedField::Nonce), + "signature" => Ok(GeneratedField::Signature), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2218,85 +2215,75 @@ impl<'de> serde::Deserialize<'de> for Params { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Params; + type Value = MsgSubmitNonce; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.Params") + formatter.write_str("struct side.dlc.MsgSubmitNonce") } - 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 nonce_queue_size__ = None; - let mut price_interval__ = None; + let mut sender__ = None; + let mut nonce__ = None; + let mut signature__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::NonceQueueSize => { - if nonce_queue_size__.is_some() { - return Err(serde::de::Error::duplicate_field("nonceQueueSize")); + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); } - nonce_queue_size__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); + sender__ = Some(map_.next_value()?); + } + GeneratedField::Nonce => { + if nonce__.is_some() { + return Err(serde::de::Error::duplicate_field("nonce")); + } + nonce__ = Some(map_.next_value()?); } - GeneratedField::PriceInterval => { - if price_interval__.is_some() { - return Err(serde::de::Error::duplicate_field("priceInterval")); + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); } - price_interval__ = Some(map_.next_value()?); + signature__ = Some(map_.next_value()?); } } } - Ok(Params { - nonce_queue_size: nonce_queue_size__.unwrap_or_default(), - price_interval: price_interval__.unwrap_or_default(), + Ok(MsgSubmitNonce { + sender: sender__.unwrap_or_default(), + nonce: nonce__.unwrap_or_default(), + signature: signature__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.Params", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgSubmitNonce", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for PriceInterval { +impl serde::Serialize for MsgSubmitNonceResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.price_pair.is_empty() { - len += 1; - } - if self.interval != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("side.dlc.PriceInterval", len)?; - if !self.price_pair.is_empty() { - struct_ser.serialize_field("pricePair", &self.price_pair)?; - } - if self.interval != 0 { - struct_ser.serialize_field("interval", &self.interval)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitNonceResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for PriceInterval { +impl<'de> serde::Deserialize<'de> for MsgSubmitNonceResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["price_pair", "pricePair", "interval"]; + const FIELDS: &[&str] = &[]; #[allow(clippy::enum_variant_names)] - enum GeneratedField { - PricePair, - Interval, - } + enum GeneratedField {} #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -2320,11 +2307,7 @@ impl<'de> serde::Deserialize<'de> for PriceInterval { where E: serde::de::Error, { - match value { - "pricePair" | "price_pair" => Ok(GeneratedField::PricePair), - "interval" => Ok(GeneratedField::Interval), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -2332,48 +2315,30 @@ impl<'de> serde::Deserialize<'de> for PriceInterval { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PriceInterval; + type Value = MsgSubmitNonceResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.PriceInterval") + formatter.write_str("struct side.dlc.MsgSubmitNonceResponse") } - 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 price_pair__ = None; - let mut interval__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::PricePair => { - if price_pair__.is_some() { - return Err(serde::de::Error::duplicate_field("pricePair")); - } - price_pair__ = Some(map_.next_value()?); - } - GeneratedField::Interval => { - if interval__.is_some() { - return Err(serde::de::Error::duplicate_field("interval")); - } - interval__ = Some( - map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? - .0, - ); - } - } + while map_.next_key::()?.is_some() { + let _ = map_.next_value::()?; } - Ok(PriceInterval { - price_pair: price_pair__.unwrap_or_default(), - interval: interval__.unwrap_or_default(), - }) + Ok(MsgSubmitNonceResponse {}) } } - deserializer.deserialize_struct("side.dlc.PriceInterval", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgSubmitNonceResponse", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryAgenciesRequest { +impl serde::Serialize for MsgSubmitOraclePubKey { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2381,129 +2346,60 @@ impl serde::Serialize for QueryAgenciesRequest { { use serde::ser::SerializeStruct; let mut len = 0; - if self.status != 0 { + if !self.sender.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("side.dlc.QueryAgenciesRequest", len)?; - if self.status != 0 { - let v = AgencyStatus::try_from(self.status).map_err(|_| { - serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) - })?; - struct_ser.serialize_field("status", &v)?; + if self.oracle_id != 0 { + len += 1; } - struct_ser.end() - } -} -#[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryAgenciesRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &["status"]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Status, + if !self.pub_key.is_empty() { + len += 1; } - #[cfg(feature = "serde")] - 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 { - "status" => Ok(GeneratedField::Status), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } + if !self.signature.is_empty() { + len += 1; } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryAgenciesRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryAgenciesRequest") - } - - fn visit_map( - self, - mut map_: V, - ) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut status__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Status => { - if status__.is_some() { - return Err(serde::de::Error::duplicate_field("status")); - } - status__ = Some(map_.next_value::()? as i32); - } - } - } - Ok(QueryAgenciesRequest { - status: status__.unwrap_or_default(), - }) - } + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgSubmitOraclePubKey", len)?; + if !self.sender.is_empty() { + struct_ser.serialize_field("sender", &self.sender)?; } - deserializer.deserialize_struct("side.dlc.QueryAgenciesRequest", FIELDS, GeneratedVisitor) - } -} -#[cfg(feature = "serde")] -impl serde::Serialize for QueryAgenciesResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.agencies.is_empty() { - len += 1; + if self.oracle_id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "oracleId", + alloc::string::ToString::to_string(&self.oracle_id).as_str(), + )?; } - let mut struct_ser = serializer.serialize_struct("side.dlc.QueryAgenciesResponse", len)?; - if !self.agencies.is_empty() { - struct_ser.serialize_field("agencies", &self.agencies)?; + if !self.pub_key.is_empty() { + struct_ser.serialize_field("pubKey", &self.pub_key)?; + } + if !self.signature.is_empty() { + struct_ser.serialize_field("signature", &self.signature)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryAgenciesResponse { +impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubKey { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["agencies"]; + const FIELDS: &[&str] = &[ + "sender", + "oracle_id", + "oracleId", + "pub_key", + "pubKey", + "signature", + ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Agencies, + Sender, + OracleId, + PubKey, + Signature, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2529,7 +2425,10 @@ impl<'de> serde::Deserialize<'de> for QueryAgenciesResponse { E: serde::de::Error, { match value { - "agencies" => Ok(GeneratedField::Agencies), + "sender" => Ok(GeneratedField::Sender), + "oracleId" | "oracle_id" => Ok(GeneratedField::OracleId), + "pubKey" | "pub_key" => Ok(GeneratedField::PubKey), + "signature" => Ok(GeneratedField::Signature), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2539,40 +2438,67 @@ impl<'de> serde::Deserialize<'de> for QueryAgenciesResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryAgenciesResponse; + type Value = MsgSubmitOraclePubKey; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryAgenciesResponse") + formatter.write_str("struct side.dlc.MsgSubmitOraclePubKey") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { - let mut agencies__ = None; + let mut sender__ = None; + let mut oracle_id__ = None; + let mut pub_key__ = None; + let mut signature__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Agencies => { - if agencies__.is_some() { - return Err(serde::de::Error::duplicate_field("agencies")); + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); } - agencies__ = Some(map_.next_value()?); + sender__ = Some(map_.next_value()?); + } + GeneratedField::OracleId => { + if oracle_id__.is_some() { + return Err(serde::de::Error::duplicate_field("oracleId")); + } + oracle_id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::PubKey => { + if pub_key__.is_some() { + return Err(serde::de::Error::duplicate_field("pubKey")); + } + pub_key__ = Some(map_.next_value()?); + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = Some(map_.next_value()?); } } } - Ok(QueryAgenciesResponse { - agencies: agencies__.unwrap_or_default(), + Ok(MsgSubmitOraclePubKey { + sender: sender__.unwrap_or_default(), + oracle_id: oracle_id__.unwrap_or_default(), + pub_key: pub_key__.unwrap_or_default(), + signature: signature__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("side.dlc.QueryAgenciesResponse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("side.dlc.MsgSubmitOraclePubKey", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryAttestationRequest { +impl serde::Serialize for MsgSubmitOraclePubKeyResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2580,12 +2506,13 @@ impl serde::Serialize for QueryAttestationRequest { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("side.dlc.QueryAttestationRequest", len)?; + let struct_ser = + serializer.serialize_struct("side.dlc.MsgSubmitOraclePubKeyResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryAttestationRequest { +impl<'de> serde::Deserialize<'de> for MsgSubmitOraclePubKeyResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -2626,34 +2553,34 @@ impl<'de> serde::Deserialize<'de> for QueryAttestationRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryAttestationRequest; + type Value = MsgSubmitOraclePubKeyResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryAttestationRequest") + formatter.write_str("struct side.dlc.MsgSubmitOraclePubKeyResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(QueryAttestationRequest {}) + Ok(MsgSubmitOraclePubKeyResponse {}) } } deserializer.deserialize_struct( - "side.dlc.QueryAttestationRequest", + "side.dlc.MsgSubmitOraclePubKeyResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryAttestationResponse { +impl serde::Serialize for MsgUpdateParams { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2661,29 +2588,35 @@ impl serde::Serialize for QueryAttestationResponse { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.attestations.is_empty() { + if !self.authority.is_empty() { len += 1; } - let mut struct_ser = - serializer.serialize_struct("side.dlc.QueryAttestationResponse", len)?; - if !self.attestations.is_empty() { - struct_ser.serialize_field("attestations", &self.attestations)?; + if self.params.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.MsgUpdateParams", len)?; + if !self.authority.is_empty() { + struct_ser.serialize_field("authority", &self.authority)?; + } + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryAttestationResponse { +impl<'de> serde::Deserialize<'de> for MsgUpdateParams { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["attestations"]; + const FIELDS: &[&str] = &["authority", "params"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Attestations, + Authority, + Params, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2709,7 +2642,8 @@ impl<'de> serde::Deserialize<'de> for QueryAttestationResponse { E: serde::de::Error, { match value { - "attestations" => Ok(GeneratedField::Attestations), + "authority" => Ok(GeneratedField::Authority), + "params" => Ok(GeneratedField::Params), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2719,44 +2653,45 @@ impl<'de> serde::Deserialize<'de> for QueryAttestationResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryAttestationResponse; + type Value = MsgUpdateParams; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryAttestationResponse") + formatter.write_str("struct side.dlc.MsgUpdateParams") } - 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 attestations__ = None; + let mut authority__ = None; + let mut params__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Attestations => { - if attestations__.is_some() { - return Err(serde::de::Error::duplicate_field("attestations")); + GeneratedField::Authority => { + if authority__.is_some() { + return Err(serde::de::Error::duplicate_field("authority")); } - attestations__ = Some(map_.next_value()?); + authority__ = Some(map_.next_value()?); + } + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map_.next_value()?; } } } - Ok(QueryAttestationResponse { - attestations: attestations__.unwrap_or_default(), + Ok(MsgUpdateParams { + authority: authority__.unwrap_or_default(), + params: params__, }) } } - deserializer.deserialize_struct( - "side.dlc.QueryAttestationResponse", - FIELDS, - GeneratedVisitor, - ) + deserializer.deserialize_struct("side.dlc.MsgUpdateParams", FIELDS, GeneratedVisitor) } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryCountNoncesRequest { +impl serde::Serialize for MsgUpdateParamsResponse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2764,12 +2699,12 @@ impl serde::Serialize for QueryCountNoncesRequest { { use serde::ser::SerializeStruct; let len = 0; - let struct_ser = serializer.serialize_struct("side.dlc.QueryCountNoncesRequest", len)?; + let struct_ser = serializer.serialize_struct("side.dlc.MsgUpdateParamsResponse", len)?; struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryCountNoncesRequest { +impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where @@ -2810,34 +2745,34 @@ impl<'de> serde::Deserialize<'de> for QueryCountNoncesRequest { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryCountNoncesRequest; + type Value = MsgUpdateParamsResponse; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryCountNoncesRequest") + formatter.write_str("struct side.dlc.MsgUpdateParamsResponse") } fn visit_map( self, mut map_: V, - ) -> core::result::Result + ) -> core::result::Result where V: serde::de::MapAccess<'de>, { while map_.next_key::()?.is_some() { let _ = map_.next_value::()?; } - Ok(QueryCountNoncesRequest {}) + Ok(MsgUpdateParamsResponse {}) } } deserializer.deserialize_struct( - "side.dlc.QueryCountNoncesRequest", + "side.dlc.MsgUpdateParamsResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryCountNoncesResponse { +impl serde::Serialize for Params { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result where @@ -2845,29 +2780,40 @@ impl serde::Serialize for QueryCountNoncesResponse { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.counts.is_empty() { + if self.nonce_queue_size != 0 { len += 1; } - let mut struct_ser = - serializer.serialize_struct("side.dlc.QueryCountNoncesResponse", len)?; - if !self.counts.is_empty() { - struct_ser.serialize_field("counts", &self.counts)?; + if !self.price_intervals.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.Params", len)?; + if self.nonce_queue_size != 0 { + struct_ser.serialize_field("nonceQueueSize", &self.nonce_queue_size)?; + } + if !self.price_intervals.is_empty() { + struct_ser.serialize_field("priceIntervals", &self.price_intervals)?; } struct_ser.end() } } #[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryCountNoncesResponse { +impl<'de> serde::Deserialize<'de> for Params { #[allow(deprecated)] fn deserialize(deserializer: D) -> core::result::Result where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["counts"]; + const FIELDS: &[&str] = &[ + "nonce_queue_size", + "nonceQueueSize", + "price_intervals", + "priceIntervals", + ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Counts, + NonceQueueSize, + PriceIntervals, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -2893,7 +2839,12 @@ impl<'de> serde::Deserialize<'de> for QueryCountNoncesResponse { E: serde::de::Error, { match value { - "counts" => Ok(GeneratedField::Counts), + "nonceQueueSize" | "nonce_queue_size" => { + Ok(GeneratedField::NonceQueueSize) + } + "priceIntervals" | "price_intervals" => { + Ok(GeneratedField::PriceIntervals) + } _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2903,46 +2854,1648 @@ impl<'de> serde::Deserialize<'de> for QueryCountNoncesResponse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryCountNoncesResponse; + type Value = Params; fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryCountNoncesResponse") + formatter.write_str("struct side.dlc.Params") } - 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 counts__ = None; + let mut nonce_queue_size__ = None; + let mut price_intervals__ = None; while let Some(k) = map_.next_key()? { match k { - GeneratedField::Counts => { - if counts__.is_some() { - return Err(serde::de::Error::duplicate_field("counts")); + GeneratedField::NonceQueueSize => { + if nonce_queue_size__.is_some() { + return Err(serde::de::Error::duplicate_field("nonceQueueSize")); } - counts__ = - Some(map_.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; + nonce_queue_size__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::PriceIntervals => { + if price_intervals__.is_some() { + return Err(serde::de::Error::duplicate_field("priceIntervals")); + } + price_intervals__ = Some(map_.next_value()?); } } } - Ok(QueryCountNoncesResponse { - counts: counts__.unwrap_or_default(), + Ok(Params { + nonce_queue_size: nonce_queue_size__.unwrap_or_default(), + price_intervals: price_intervals__.unwrap_or_default(), }) } } - deserializer.deserialize_struct( - "side.dlc.QueryCountNoncesResponse", + deserializer.deserialize_struct("side.dlc.Params", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for PriceInterval { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.price_pair.is_empty() { + len += 1; + } + if self.interval != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.PriceInterval", len)?; + if !self.price_pair.is_empty() { + struct_ser.serialize_field("pricePair", &self.price_pair)?; + } + if self.interval != 0 { + struct_ser.serialize_field("interval", &self.interval)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for PriceInterval { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["price_pair", "pricePair", "interval"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PricePair, + Interval, + } + #[cfg(feature = "serde")] + 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 { + "pricePair" | "price_pair" => Ok(GeneratedField::PricePair), + "interval" => Ok(GeneratedField::Interval), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PriceInterval; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.PriceInterval") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut price_pair__ = None; + let mut interval__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PricePair => { + if price_pair__.is_some() { + return Err(serde::de::Error::duplicate_field("pricePair")); + } + price_pair__ = Some(map_.next_value()?); + } + GeneratedField::Interval => { + if interval__.is_some() { + return Err(serde::de::Error::duplicate_field("interval")); + } + interval__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(PriceInterval { + price_pair: price_pair__.unwrap_or_default(), + interval: interval__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.dlc.PriceInterval", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAgenciesRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.status != 0 { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryAgenciesRequest", len)?; + if self.status != 0 { + let v = AgencyStatus::try_from(self.status).map_err(|_| { + serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) + })?; + struct_ser.serialize_field("status", &v)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAgenciesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["status", "pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Status, + Pagination, + } + #[cfg(feature = "serde")] + 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 { + "status" => Ok(GeneratedField::Status), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAgenciesRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAgenciesRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut status__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryAgenciesRequest { + status: status__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryAgenciesRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAgenciesResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.agencies.is_empty() { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryAgenciesResponse", len)?; + if !self.agencies.is_empty() { + struct_ser.serialize_field("agencies", &self.agencies)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAgenciesResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["agencies", "pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Agencies, + Pagination, + } + #[cfg(feature = "serde")] + 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 { + "agencies" => Ok(GeneratedField::Agencies), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAgenciesResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAgenciesResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut agencies__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Agencies => { + if agencies__.is_some() { + return Err(serde::de::Error::duplicate_field("agencies")); + } + agencies__ = Some(map_.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryAgenciesResponse { + agencies: agencies__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryAgenciesResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAttestationRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.id != 0 { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.dlc.QueryAttestationRequest", len)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAttestationRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["id"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + } + #[cfg(feature = "serde")] + 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 { + "id" => Ok(GeneratedField::Id), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAttestationRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAttestationRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryAttestationRequest { + id: id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryAttestationRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAttestationResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.attestation.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.dlc.QueryAttestationResponse", len)?; + if let Some(v) = self.attestation.as_ref() { + struct_ser.serialize_field("attestation", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAttestationResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["attestation"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Attestation, + } + #[cfg(feature = "serde")] + 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 { + "attestation" => Ok(GeneratedField::Attestation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAttestationResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAttestationResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut attestation__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Attestation => { + if attestation__.is_some() { + return Err(serde::de::Error::duplicate_field("attestation")); + } + attestation__ = map_.next_value()?; + } + } + } + Ok(QueryAttestationResponse { + attestation: attestation__, + }) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryAttestationResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAttestationsRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.dlc.QueryAttestationsRequest", len)?; + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAttestationsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Pagination, + } + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting( + &self, + formatter: &mut core::fmt::Formatter<'_>, + ) -> core::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> core::result::Result + where + E: serde::de::Error, + { + match value { + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAttestationsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAttestationsRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryAttestationsRequest { + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryAttestationsRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryAttestationsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.attestations.is_empty() { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.dlc.QueryAttestationsResponse", len)?; + if !self.attestations.is_empty() { + struct_ser.serialize_field("attestations", &self.attestations)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryAttestationsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["attestations", "pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Attestations, + Pagination, + } + #[cfg(feature = "serde")] + 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 { + "attestations" => Ok(GeneratedField::Attestations), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryAttestationsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryAttestationsResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut attestations__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Attestations => { + if attestations__.is_some() { + return Err(serde::de::Error::duplicate_field("attestations")); + } + attestations__ = Some(map_.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryAttestationsResponse { + attestations: attestations__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryAttestationsResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryCountNoncesRequest { + #[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("side.dlc.QueryCountNoncesRequest", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryCountNoncesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = QueryCountNoncesRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryCountNoncesRequest") + } + + 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(QueryCountNoncesRequest {}) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryCountNoncesRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryCountNoncesResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.counts.is_empty() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.dlc.QueryCountNoncesResponse", len)?; + if !self.counts.is_empty() { + struct_ser.serialize_field("counts", &self.counts)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryCountNoncesResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["counts"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Counts, + } + #[cfg(feature = "serde")] + 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 { + "counts" => Ok(GeneratedField::Counts), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryCountNoncesResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryCountNoncesResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut counts__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Counts => { + if counts__.is_some() { + return Err(serde::de::Error::duplicate_field("counts")); + } + counts__ = + Some(map_.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(QueryCountNoncesResponse { + counts: counts__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.dlc.QueryCountNoncesResponse", FIELDS, GeneratedVisitor, ) } } #[cfg(feature = "serde")] +impl serde::Serialize for QueryEventRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.id != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryEventRequest", len)?; + if self.id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser + .serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryEventRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["id"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + } + #[cfg(feature = "serde")] + 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 { + "id" => Ok(GeneratedField::Id), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEventRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryEventRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryEventRequest { + id: id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryEventRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryEventResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.event.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryEventResponse", len)?; + if let Some(v) = self.event.as_ref() { + struct_ser.serialize_field("event", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryEventResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["event"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Event, + } + #[cfg(feature = "serde")] + 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 { + "event" => Ok(GeneratedField::Event), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEventResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryEventResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut event__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Event => { + if event__.is_some() { + return Err(serde::de::Error::duplicate_field("event")); + } + event__ = map_.next_value()?; + } + } + } + Ok(QueryEventResponse { event: event__ }) + } + } + deserializer.deserialize_struct("side.dlc.QueryEventResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryEventsRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.triggered { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryEventsRequest", len)?; + if self.triggered { + struct_ser.serialize_field("triggered", &self.triggered)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryEventsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["triggered", "pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Triggered, + Pagination, + } + #[cfg(feature = "serde")] + 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 { + "triggered" => Ok(GeneratedField::Triggered), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEventsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryEventsRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut triggered__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Triggered => { + if triggered__.is_some() { + return Err(serde::de::Error::duplicate_field("triggered")); + } + triggered__ = Some(map_.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryEventsRequest { + triggered: triggered__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryEventsRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryEventsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.events.is_empty() { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryEventsResponse", len)?; + if !self.events.is_empty() { + struct_ser.serialize_field("events", &self.events)?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryEventsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["events", "pagination"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Events, + Pagination, + } + #[cfg(feature = "serde")] + 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 { + "events" => Ok(GeneratedField::Events), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryEventsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryEventsResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut events__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Events => { + if events__.is_some() { + return Err(serde::de::Error::duplicate_field("events")); + } + events__ = Some(map_.next_value()?); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } + } + Ok(QueryEventsResponse { + events: events__.unwrap_or_default(), + pagination: pagination__, + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryEventsResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryNonceRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.oracle_id != 0 { + len += 1; + } + if self.index != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryNonceRequest", len)?; + if self.oracle_id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "oracleId", + alloc::string::ToString::to_string(&self.oracle_id).as_str(), + )?; + } + if self.index != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "index", + alloc::string::ToString::to_string(&self.index).as_str(), + )?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryNonceRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["oracle_id", "oracleId", "index"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OracleId, + Index, + } + #[cfg(feature = "serde")] + 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 { + "oracleId" | "oracle_id" => Ok(GeneratedField::OracleId), + "index" => Ok(GeneratedField::Index), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryNonceRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryNonceRequest") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut oracle_id__ = None; + let mut index__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::OracleId => { + if oracle_id__.is_some() { + return Err(serde::de::Error::duplicate_field("oracleId")); + } + oracle_id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::Index => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("index")); + } + index__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryNonceRequest { + oracle_id: oracle_id__.unwrap_or_default(), + index: index__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.dlc.QueryNonceRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryNonceResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.nonce.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryNonceResponse", len)?; + if let Some(v) = self.nonce.as_ref() { + struct_ser.serialize_field("nonce", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryNonceResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["nonce"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Nonce, + } + #[cfg(feature = "serde")] + 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 { + "nonce" => Ok(GeneratedField::Nonce), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryNonceResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.dlc.QueryNonceResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut nonce__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Nonce => { + if nonce__.is_some() { + return Err(serde::de::Error::duplicate_field("nonce")); + } + nonce__ = map_.next_value()?; + } + } + } + Ok(QueryNonceResponse { nonce: nonce__ }) + } + } + deserializer.deserialize_struct("side.dlc.QueryNonceResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] impl serde::Serialize for QueryNoncesRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -2950,8 +4503,24 @@ impl serde::Serialize for QueryNoncesRequest { S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("side.dlc.QueryNoncesRequest", len)?; + let mut len = 0; + if self.oracle_id != 0 { + len += 1; + } + if self.pagination.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.dlc.QueryNoncesRequest", len)?; + if self.oracle_id != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "oracleId", + alloc::string::ToString::to_string(&self.oracle_id).as_str(), + )?; + } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } struct_ser.end() } } @@ -2962,10 +4531,13 @@ impl<'de> serde::Deserialize<'de> for QueryNoncesRequest { where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &[]; + const FIELDS: &[&str] = &["oracle_id", "oracleId", "pagination"]; #[allow(clippy::enum_variant_names)] - enum GeneratedField {} + enum GeneratedField { + OracleId, + Pagination, + } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> core::result::Result @@ -2989,7 +4561,11 @@ impl<'de> serde::Deserialize<'de> for QueryNoncesRequest { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "oracleId" | "oracle_id" => Ok(GeneratedField::OracleId), + "pagination" => Ok(GeneratedField::Pagination), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -3007,10 +4583,31 @@ impl<'de> serde::Deserialize<'de> for QueryNoncesRequest { where V: serde::de::MapAccess<'de>, { - while map_.next_key::()?.is_some() { - let _ = map_.next_value::()?; + let mut oracle_id__ = None; + let mut pagination__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::OracleId => { + if oracle_id__.is_some() { + return Err(serde::de::Error::duplicate_field("oracleId")); + } + oracle_id__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } + } } - Ok(QueryNoncesRequest {}) + Ok(QueryNoncesRequest { + oracle_id: oracle_id__.unwrap_or_default(), + pagination: pagination__, + }) } } deserializer.deserialize_struct("side.dlc.QueryNoncesRequest", FIELDS, GeneratedVisitor) @@ -3142,6 +4739,9 @@ impl serde::Serialize for QueryOraclesRequest { if self.status != 0 { len += 1; } + if self.pagination.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("side.dlc.QueryOraclesRequest", len)?; if self.status != 0 { let v = DlcOracleStatus::try_from(self.status).map_err(|_| { @@ -3149,6 +4749,9 @@ impl serde::Serialize for QueryOraclesRequest { })?; struct_ser.serialize_field("status", &v)?; } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } struct_ser.end() } } @@ -3159,11 +4762,12 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesRequest { where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["status"]; + const FIELDS: &[&str] = &["status", "pagination"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Status, + Pagination, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -3190,6 +4794,7 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesRequest { { match value { "status" => Ok(GeneratedField::Status), + "pagination" => Ok(GeneratedField::Pagination), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3213,6 +4818,7 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesRequest { V: serde::de::MapAccess<'de>, { let mut status__ = None; + let mut pagination__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Status => { @@ -3221,10 +4827,17 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesRequest { } status__ = Some(map_.next_value::()? as i32); } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } } } Ok(QueryOraclesRequest { status: status__.unwrap_or_default(), + pagination: pagination__, }) } } @@ -3243,10 +4856,16 @@ impl serde::Serialize for QueryOraclesResponse { if !self.oracles.is_empty() { len += 1; } + if self.pagination.is_some() { + len += 1; + } let mut struct_ser = serializer.serialize_struct("side.dlc.QueryOraclesResponse", len)?; if !self.oracles.is_empty() { struct_ser.serialize_field("oracles", &self.oracles)?; } + if let Some(v) = self.pagination.as_ref() { + struct_ser.serialize_field("pagination", v)?; + } struct_ser.end() } } @@ -3257,11 +4876,12 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesResponse { where D: serde::Deserializer<'de>, { - const FIELDS: &[&str] = &["oracles"]; + const FIELDS: &[&str] = &["oracles", "pagination"]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Oracles, + Pagination, } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -3288,6 +4908,7 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesResponse { { match value { "oracles" => Ok(GeneratedField::Oracles), + "pagination" => Ok(GeneratedField::Pagination), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3311,6 +4932,7 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesResponse { V: serde::de::MapAccess<'de>, { let mut oracles__ = None; + let mut pagination__ = None; while let Some(k) = map_.next_key()? { match k { GeneratedField::Oracles => { @@ -3319,10 +4941,17 @@ impl<'de> serde::Deserialize<'de> for QueryOraclesResponse { } oracles__ = Some(map_.next_value()?); } + GeneratedField::Pagination => { + if pagination__.is_some() { + return Err(serde::de::Error::duplicate_field("pagination")); + } + pagination__ = map_.next_value()?; + } } } Ok(QueryOraclesResponse { oracles: oracles__.unwrap_or_default(), + pagination: pagination__, }) } } @@ -3500,239 +5129,6 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse { } } #[cfg(feature = "serde")] -impl serde::Serialize for QueryPriceEventRequest { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.has_triggered { - len += 1; - } - if self.pagination.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("side.dlc.QueryPriceEventRequest", len)?; - if self.has_triggered { - struct_ser.serialize_field("hasTriggered", &self.has_triggered)?; - } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -#[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryPriceEventRequest { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &["has_triggered", "hasTriggered", "pagination"]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - HasTriggered, - Pagination, - } - #[cfg(feature = "serde")] - 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 { - "hasTriggered" | "has_triggered" => Ok(GeneratedField::HasTriggered), - "pagination" => Ok(GeneratedField::Pagination), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPriceEventRequest; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryPriceEventRequest") - } - - fn visit_map( - self, - mut map_: V, - ) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut has_triggered__ = None; - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::HasTriggered => { - if has_triggered__.is_some() { - return Err(serde::de::Error::duplicate_field("hasTriggered")); - } - has_triggered__ = Some(map_.next_value()?); - } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryPriceEventRequest { - has_triggered: has_triggered__.unwrap_or_default(), - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct("side.dlc.QueryPriceEventRequest", FIELDS, GeneratedVisitor) - } -} -#[cfg(feature = "serde")] -impl serde::Serialize for QueryPriceEventResponse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> core::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.events.is_empty() { - len += 1; - } - if self.pagination.is_some() { - len += 1; - } - let mut struct_ser = - serializer.serialize_struct("side.dlc.QueryPriceEventResponse", len)?; - if !self.events.is_empty() { - struct_ser.serialize_field("events", &self.events)?; - } - if let Some(v) = self.pagination.as_ref() { - struct_ser.serialize_field("pagination", v)?; - } - struct_ser.end() - } -} -#[cfg(feature = "serde")] -impl<'de> serde::Deserialize<'de> for QueryPriceEventResponse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> core::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &["events", "pagination"]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Events, - Pagination, - } - #[cfg(feature = "serde")] - 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 { - "events" => Ok(GeneratedField::Events), - "pagination" => Ok(GeneratedField::Pagination), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = QueryPriceEventResponse; - - fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - formatter.write_str("struct side.dlc.QueryPriceEventResponse") - } - - fn visit_map( - self, - mut map_: V, - ) -> core::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut events__ = None; - let mut pagination__ = None; - while let Some(k) = map_.next_key()? { - match k { - GeneratedField::Events => { - if events__.is_some() { - return Err(serde::de::Error::duplicate_field("events")); - } - events__ = Some(map_.next_value()?); - } - GeneratedField::Pagination => { - if pagination__.is_some() { - return Err(serde::de::Error::duplicate_field("pagination")); - } - pagination__ = map_.next_value()?; - } - } - } - Ok(QueryPriceEventResponse { - events: events__.unwrap_or_default(), - pagination: pagination__, - }) - } - } - deserializer.deserialize_struct( - "side.dlc.QueryPriceEventResponse", - FIELDS, - GeneratedVisitor, - ) - } -} -#[cfg(feature = "serde")] impl serde::Serialize for QueryPriceRequest { #[allow(deprecated)] fn serialize(&self, serializer: S) -> core::result::Result @@ -3841,7 +5237,11 @@ impl serde::Serialize for QueryPriceResponse { } let mut struct_ser = serializer.serialize_struct("side.dlc.QueryPriceResponse", len)?; if self.price != 0 { - struct_ser.serialize_field("price", &self.price)?; + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "price", + alloc::string::ToString::to_string(&self.price).as_str(), + )?; } struct_ser.end() } diff --git a/side-proto/src/prost/side/side.dlc.tonic.rs b/side-proto/src/prost/side/side.dlc.tonic.rs index 1334c0a..363782a 100644 --- a/side-proto/src/prost/side/side.dlc.tonic.rs +++ b/side-proto/src/prost/side/side.dlc.tonic.rs @@ -103,10 +103,28 @@ pub mod query_client { .insert(GrpcMethod::new("side.dlc.Query", "Params")); self.inner.unary(req, path, codec).await } + pub async fn event( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Event"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Query", "Event")); + self.inner.unary(req, path, codec).await + } pub async fn events( &mut self, - request: impl tonic::IntoRequest, - ) -> core::result::Result, tonic::Status> + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( @@ -121,10 +139,28 @@ pub mod query_client { .insert(GrpcMethod::new("side.dlc.Query", "Events")); self.inner.unary(req, path, codec).await } - pub async fn attestations( + pub async fn attestation( &mut self, request: impl tonic::IntoRequest, ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Attestation"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Query", "Attestation")); + self.inner.unary(req, path, codec).await + } + pub async fn attestations( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( @@ -157,6 +193,24 @@ pub mod query_client { .insert(GrpcMethod::new("side.dlc.Query", "Price")); self.inner.unary(req, path, codec).await } + pub async fn nonce( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Nonce"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Query", "Nonce")); + self.inner.unary(req, path, codec).await + } pub async fn nonces( &mut self, request: impl tonic::IntoRequest, @@ -243,18 +297,30 @@ pub mod query_server { &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn event( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; async fn events( &self, - request: tonic::Request, - ) -> core::result::Result, tonic::Status>; - async fn attestations( + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn attestation( &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn attestations( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; async fn price( &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; + async fn nonce( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; async fn nonces( &self, request: tonic::Request, @@ -386,15 +452,53 @@ pub mod query_server { }; Box::pin(fut) } + "/side.dlc.Query/Event" => { + #[allow(non_camel_case_types)] + struct EventSvc(pub Arc); + impl tonic::server::UnaryService for EventSvc { + type Response = super::QueryEventResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).event(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 = EventSvc(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) + } "/side.dlc.Query/Events" => { #[allow(non_camel_case_types)] struct EventsSvc(pub Arc); - impl tonic::server::UnaryService for EventsSvc { - type Response = super::QueryPriceEventResponse; + impl tonic::server::UnaryService for EventsSvc { + type Response = super::QueryEventsResponse; type Future = BoxFuture, 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).events(request).await }; @@ -424,15 +528,53 @@ pub mod query_server { }; Box::pin(fut) } - "/side.dlc.Query/Attestations" => { + "/side.dlc.Query/Attestation" => { #[allow(non_camel_case_types)] - struct AttestationsSvc(pub Arc); - impl tonic::server::UnaryService for AttestationsSvc { + struct AttestationSvc(pub Arc); + impl tonic::server::UnaryService for AttestationSvc { type Response = super::QueryAttestationResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).attestation(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 = AttestationSvc(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) + } + "/side.dlc.Query/Attestations" => { + #[allow(non_camel_case_types)] + struct AttestationsSvc(pub Arc); + impl tonic::server::UnaryService for AttestationsSvc { + type Response = super::QueryAttestationsResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { (*inner).attestations(request).await }; @@ -500,6 +642,44 @@ pub mod query_server { }; Box::pin(fut) } + "/side.dlc.Query/Nonce" => { + #[allow(non_camel_case_types)] + struct NonceSvc(pub Arc); + impl tonic::server::UnaryService for NonceSvc { + type Response = super::QueryNonceResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).nonce(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 = NonceSvc(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) + } "/side.dlc.Query/Nonces" => { #[allow(non_camel_case_types)] struct NoncesSvc(pub Arc); @@ -808,11 +988,11 @@ pub mod msg_client { .insert(GrpcMethod::new("side.dlc.Msg", "SubmitAttestation")); self.inner.unary(req, path, codec).await } - pub async fn submit_oracle_pubkey( + pub async fn submit_oracle_pub_key( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> core::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { @@ -822,17 +1002,17 @@ pub mod msg_client { ) })?; let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/SubmitOraclePubkey"); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/SubmitOraclePubKey"); let mut req = request.into_request(); req.extensions_mut() - .insert(GrpcMethod::new("side.dlc.Msg", "SubmitOraclePubkey")); + .insert(GrpcMethod::new("side.dlc.Msg", "SubmitOraclePubKey")); self.inner.unary(req, path, codec).await } - pub async fn submit_agency_address( + pub async fn submit_agency_pub_key( &mut self, - request: impl tonic::IntoRequest, + request: impl tonic::IntoRequest, ) -> core::result::Result< - tonic::Response, + tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { @@ -842,10 +1022,64 @@ pub mod msg_client { ) })?; let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/SubmitAgencyAddress"); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/SubmitAgencyPubKey"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Msg", "SubmitAgencyPubKey")); + self.inner.unary(req, path, codec).await + } + pub async fn create_oracle( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/CreateOracle"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Msg", "CreateOracle")); + self.inner.unary(req, path, codec).await + } + pub async fn create_agency( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/CreateAgency"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.dlc.Msg", "CreateAgency")); + self.inner.unary(req, path, codec).await + } + pub async fn update_params( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/UpdateParams"); let mut req = request.into_request(); req.extensions_mut() - .insert(GrpcMethod::new("side.dlc.Msg", "SubmitAgencyAddress")); + .insert(GrpcMethod::new("side.dlc.Msg", "UpdateParams")); self.inner.unary(req, path, codec).await } } @@ -866,20 +1100,32 @@ pub mod msg_server { &self, request: tonic::Request, ) -> core::result::Result, tonic::Status>; - async fn submit_oracle_pubkey( + async fn submit_oracle_pub_key( &self, - request: tonic::Request, + request: tonic::Request, ) -> core::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; - async fn submit_agency_address( + async fn submit_agency_pub_key( &self, - request: tonic::Request, + request: tonic::Request, ) -> core::result::Result< - tonic::Response, + tonic::Response, tonic::Status, >; + async fn create_oracle( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn create_agency( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn update_params( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; } #[derive(Debug)] pub struct MsgServer { @@ -1033,20 +1279,20 @@ pub mod msg_server { }; Box::pin(fut) } - "/side.dlc.Msg/SubmitOraclePubkey" => { + "/side.dlc.Msg/SubmitOraclePubKey" => { #[allow(non_camel_case_types)] - struct SubmitOraclePubkeySvc(pub Arc); - impl tonic::server::UnaryService - for SubmitOraclePubkeySvc + struct SubmitOraclePubKeySvc(pub Arc); + impl tonic::server::UnaryService + for SubmitOraclePubKeySvc { - type Response = super::MsgSubmitOraclePubkeyResponse; + type Response = super::MsgSubmitOraclePubKeyResponse; type Future = BoxFuture, 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).submit_oracle_pubkey(request).await }; + let fut = async move { (*inner).submit_oracle_pub_key(request).await }; Box::pin(fut) } } @@ -1057,7 +1303,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = SubmitOraclePubkeySvc(inner); + let method = SubmitOraclePubKeySvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1073,20 +1319,134 @@ pub mod msg_server { }; Box::pin(fut) } - "/side.dlc.Msg/SubmitAgencyAddress" => { + "/side.dlc.Msg/SubmitAgencyPubKey" => { #[allow(non_camel_case_types)] - struct SubmitAgencyAddressSvc(pub Arc); - impl tonic::server::UnaryService - for SubmitAgencyAddressSvc + struct SubmitAgencyPubKeySvc(pub Arc); + impl tonic::server::UnaryService + for SubmitAgencyPubKeySvc { - type Response = super::MsgSubmitAgencyAddressResponse; + type Response = super::MsgSubmitAgencyPubKeyResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).submit_agency_pub_key(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 = SubmitAgencyPubKeySvc(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) + } + "/side.dlc.Msg/CreateOracle" => { + #[allow(non_camel_case_types)] + struct CreateOracleSvc(pub Arc); + impl tonic::server::UnaryService for CreateOracleSvc { + type Response = super::MsgCreateOracleResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).create_oracle(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 = CreateOracleSvc(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) + } + "/side.dlc.Msg/CreateAgency" => { + #[allow(non_camel_case_types)] + struct CreateAgencySvc(pub Arc); + impl tonic::server::UnaryService for CreateAgencySvc { + type Response = super::MsgCreateAgencyResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).create_agency(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 = CreateAgencySvc(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) + } + "/side.dlc.Msg/UpdateParams" => { + #[allow(non_camel_case_types)] + struct UpdateParamsSvc(pub Arc); + impl tonic::server::UnaryService for UpdateParamsSvc { + type Response = super::MsgUpdateParamsResponse; type Future = BoxFuture, 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).submit_agency_address(request).await }; + let fut = async move { (*inner).update_params(request).await }; Box::pin(fut) } } @@ -1097,7 +1457,7 @@ pub mod msg_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = SubmitAgencyAddressSvc(inner); + let method = UpdateParamsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( diff --git a/side-proto/src/prost/side/side.lending.rs b/side-proto/src/prost/side/side.lending.rs new file mode 100644 index 0000000..76c6296 --- /dev/null +++ b/side-proto/src/prost/side/side.lending.rs @@ -0,0 +1,623 @@ +// @generated +/// Params defines the parameters for the module. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + #[prost(string, tag = "1")] + pub supply_rate_permille: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub borrow_rate_permille: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub fee_recipient: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "4")] + pub pool_creators: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag = "5")] + pub min_initial_ltv_percent: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub liquidation_threshold_percent: ::prost::alloc::string::String, +} +impl ::prost::Name for Params { + const NAME: &'static str = "Params"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LendingPool { + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub supply: ::core::option::Option, + #[prost(string, tag = "3")] + pub total_shares: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub borrowed_amount: ::prost::alloc::string::String, + #[prost(enumeration = "PoolStatus", tag = "5")] + pub status: i32, +} +impl ::prost::Name for LendingPool { + const NAME: &'static str = "LendingPool"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Loan { + /// id + #[prost(string, tag = "1")] + pub vault_address: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub borrower: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub agency: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub hash_loan_secret: ::prost::alloc::string::String, + #[prost(int64, tag = "5")] + pub maturity_time: i64, + #[prost(int64, tag = "6")] + pub final_timeout: i64, + #[prost(message, optional, tag = "7")] + pub borrow_amount: ::core::option::Option, + #[prost(string, tag = "8")] + pub fees: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub interests: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub term: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub event_id: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub attestation_id: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "13")] + pub deposit_txs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag = "14")] + pub collateral_amount: ::prost::alloc::string::String, + #[prost(string, tag = "15")] + pub loan_secret: ::prost::alloc::string::String, + #[prost(message, optional, tag = "16")] + pub create_at: ::core::option::Option<::tendermint_proto::google::protobuf::Timestamp>, + #[prost(enumeration = "LoanStatus", tag = "17")] + pub status: i32, + #[prost(string, tag = "18")] + pub pool_id: ::prost::alloc::string::String, +} +impl ::prost::Name for Loan { + const NAME: &'static str = "Loan"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Cet { + #[prost(string, tag = "1")] + pub loan_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub cets: ::prost::alloc::string::String, +} +impl ::prost::Name for Cet { + const NAME: &'static str = "CET"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DepositLog { + #[prost(string, tag = "2")] + pub txid: ::prost::alloc::string::String, + #[prost(string, tag = "1")] + pub vault_address: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub deposit_tx: ::prost::alloc::string::String, +} +impl ::prost::Name for DepositLog { + const NAME: &'static str = "DepositLog"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Repayment { + #[prost(string, tag = "1")] + pub loan_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub txid: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub tx: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub repay_adaptor_point: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub borrower_signature: ::prost::alloc::string::String, + #[prost(message, optional, tag = "6")] + pub create_at: ::core::option::Option<::tendermint_proto::google::protobuf::Timestamp>, +} +impl ::prost::Name for Repayment { + const NAME: &'static str = "Repayment"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +/// Status options for a lending pool +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PoolStatus { + Active = 0, + Inactive = 1, +} +impl PoolStatus { + /// 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 { + PoolStatus::Active => "ACTIVE", + PoolStatus::Inactive => "INACTIVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTIVE" => Some(Self::Active), + "INACTIVE" => Some(Self::Inactive), + _ => None, + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum LoanStatus { + /// Loan Application + Apply = 0, + /// Loan Approval + Approve = 1, + /// Loan Disbursement + Disburse = 2, + /// Loan Repayment + Repay = 3, + /// Loan Default/Delinquency + Default = 4, + /// Loan Liquidation + Liquidate = 5, + /// Loan Closure + Close = 6, +} +impl LoanStatus { + /// 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 { + LoanStatus::Apply => "Apply", + LoanStatus::Approve => "Approve", + LoanStatus::Disburse => "Disburse", + LoanStatus::Repay => "Repay", + LoanStatus::Default => "Default", + LoanStatus::Liquidate => "Liquidate", + LoanStatus::Close => "Close", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "Apply" => Some(Self::Apply), + "Approve" => Some(Self::Approve), + "Disburse" => Some(Self::Disburse), + "Repay" => Some(Self::Repay), + "Default" => Some(Self::Default), + "Liquidate" => Some(Self::Liquidate), + "Close" => Some(Self::Close), + _ => None, + } + } +} +/// GenesisState defines the lending module's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub pools: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisState { + const NAME: &'static str = "GenesisState"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryLiquidationEventRequest { + #[prost(message, optional, tag = "1")] + pub borrow_amount: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub collateral_acmount: ::core::option::Option, +} +impl ::prost::Name for QueryLiquidationEventRequest { + const NAME: &'static str = "QueryLiquidationEventRequest"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryLiquidationEventResponse { + #[prost(string, tag = "1")] + pub event_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub oracle_pubkey: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub nonce: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub price: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryLiquidationEventResponse { + const NAME: &'static str = "QueryLiquidationEventResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCollateralAddressRequest { + #[prost(string, tag = "1")] + pub borrower_pubkey: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub hash_of_loan_secret: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub maturity_time: u64, + #[prost(uint64, tag = "4")] + pub final_timeout: u64, +} +impl ::prost::Name for QueryCollateralAddressRequest { + const NAME: &'static str = "QueryCollateralAddressRequest"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCollateralAddressResponse { + #[prost(string, tag = "1")] + pub address: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryCollateralAddressResponse { + const NAME: &'static str = "QueryCollateralAddressResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +/// QueryParamsRequest is request type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest {} +impl ::prost::Name for QueryParamsRequest { + const NAME: &'static str = "QueryParamsRequest"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +/// QueryParamsResponse is response type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsResponse { + #[prost(message, optional, tag = "1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { + const NAME: &'static str = "QueryParamsResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +/// QueryLoanCETRequest is request type for the Query/LoanCET RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryLoanCetRequest {} +impl ::prost::Name for QueryLoanCetRequest { + const NAME: &'static str = "QueryLoanCETRequest"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +/// QueryLoanCETResponse is response type for the Query/LoanCET RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryLoanCetResponse {} +impl ::prost::Name for QueryLoanCetResponse { + const NAME: &'static str = "QueryLoanCETResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryRepaymentTxRequest { + #[prost(string, tag = "1")] + pub loan_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryRepaymentTxRequest { + const NAME: &'static str = "QueryRepaymentTxRequest"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryRepaymentTxResponse { + #[prost(string, tag = "1")] + pub claim_tx: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryRepaymentTxResponse { + const NAME: &'static str = "QueryRepaymentTxResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreatePool { + #[prost(string, tag = "1")] + pub creator: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub pool_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub lending_asset: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgCreatePool { + const NAME: &'static str = "MsgCreatePool"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreatePoolResponse {} +impl ::prost::Name for MsgCreatePoolResponse { + const NAME: &'static str = "MsgCreatePoolResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRepay { + #[prost(string, tag = "1")] + pub borrower: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub loan_id: ::prost::alloc::string::String, + /// string claim_tx_id = 4; + /// string adaptor_signature = 5; + #[prost(string, tag = "3")] + pub adaptor_point: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRepay { + const NAME: &'static str = "MsgRepay"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRepayResponse {} +impl ::prost::Name for MsgRepayResponse { + const NAME: &'static str = "MsgRepayResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRedeem { + #[prost(string, tag = "1")] + pub borrower: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub loan_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub loan_secret: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRedeem { + const NAME: &'static str = "MsgRedeem"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRedeemResponse {} +impl ::prost::Name for MsgRedeemResponse { + const NAME: &'static str = "MsgRedeemResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgAddLiquidity { + #[prost(string, tag = "1")] + pub pool_id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub lender: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub amount: ::core::option::Option, +} +impl ::prost::Name for MsgAddLiquidity { + const NAME: &'static str = "MsgAddLiquidity"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgAddLiquidityResponse { + #[prost(message, optional, tag = "1")] + pub shares: ::core::option::Option, +} +impl ::prost::Name for MsgAddLiquidityResponse { + const NAME: &'static str = "MsgAddLiquidityResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRemoveLiquidity { + #[prost(string, tag = "1")] + pub lender: ::prost::alloc::string::String, + #[prost(message, optional, tag = "2")] + pub shares: ::core::option::Option, +} +impl ::prost::Name for MsgRemoveLiquidity { + const NAME: &'static str = "MsgRemoveLiquidity"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRemoveLiquidityResponse { + #[prost(message, optional, tag = "1")] + pub amount: ::core::option::Option, +} +impl ::prost::Name for MsgRemoveLiquidityResponse { + const NAME: &'static str = "MsgRemoveLiquidityResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgApply { + #[prost(string, tag = "1")] + pub borrower: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub borrower_pubkey: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub loan_secret_hash: ::prost::alloc::string::String, + #[prost(int64, tag = "4")] + pub maturity_time: i64, + #[prost(int64, tag = "5")] + pub final_timeout: i64, + #[prost(string, tag = "6")] + pub pool_id: ::prost::alloc::string::String, + #[prost(message, optional, tag = "7")] + pub borrow_amount: ::core::option::Option, + #[prost(string, tag = "8")] + pub event_id: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub cets: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub deposit_tx: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgApply { + const NAME: &'static str = "MsgApply"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgApplyResponse { + #[prost(string, tag = "1")] + pub vault_address: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgApplyResponse { + const NAME: &'static str = "MsgApplyResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgApprove { + #[prost(string, tag = "1")] + pub relayer: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub deposit_tx_id: ::prost::alloc::string::String, + #[prost(uint64, tag = "3")] + pub height: u64, + #[prost(string, tag = "4")] + pub poof: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgApprove { + const NAME: &'static str = "MsgApprove"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgApproveResponse {} +impl ::prost::Name for MsgApproveResponse { + const NAME: &'static str = "MsgApproveResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgClose { + #[prost(string, tag = "1")] + pub relayer: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub loan_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub signature: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgClose { + const NAME: &'static str = "MsgClose"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCloseResponse {} +impl ::prost::Name for MsgCloseResponse { + const NAME: &'static str = "MsgCloseResponse"; + const PACKAGE: &'static str = "side.lending"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("side.lending.{}", Self::NAME) + } +} +include!("side.lending.serde.rs"); +include!("side.lending.tonic.rs"); +// @@protoc_insertion_point(module) diff --git a/side-proto/src/prost/side/side.lending.serde.rs b/side-proto/src/prost/side/side.lending.serde.rs new file mode 100644 index 0000000..f65d83d --- /dev/null +++ b/side-proto/src/prost/side/side.lending.serde.rs @@ -0,0 +1,4469 @@ +// @generated +#[cfg(feature = "serde")] +impl serde::Serialize for Cet { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.loan_id.is_empty() { + len += 1; + } + if !self.cets.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.CET", len)?; + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + if !self.cets.is_empty() { + struct_ser.serialize_field("cets", &self.cets)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for Cet { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["loan_id", "loanId", "cets"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LoanId, + Cets, + } + #[cfg(feature = "serde")] + 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 { + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + "cets" => Ok(GeneratedField::Cets), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Cet; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.CET") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut loan_id__ = None; + let mut cets__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + GeneratedField::Cets => { + if cets__.is_some() { + return Err(serde::de::Error::duplicate_field("cets")); + } + cets__ = Some(map_.next_value()?); + } + } + } + Ok(Cet { + loan_id: loan_id__.unwrap_or_default(), + cets: cets__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.CET", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for DepositLog { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.txid.is_empty() { + len += 1; + } + if !self.vault_address.is_empty() { + len += 1; + } + if !self.deposit_tx.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.DepositLog", len)?; + if !self.txid.is_empty() { + struct_ser.serialize_field("txid", &self.txid)?; + } + if !self.vault_address.is_empty() { + struct_ser.serialize_field("vaultAddress", &self.vault_address)?; + } + if !self.deposit_tx.is_empty() { + struct_ser.serialize_field("depositTx", &self.deposit_tx)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for DepositLog { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "txid", + "vault_address", + "vaultAddress", + "deposit_tx", + "depositTx", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Txid, + VaultAddress, + DepositTx, + } + #[cfg(feature = "serde")] + 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 { + "txid" => Ok(GeneratedField::Txid), + "vaultAddress" | "vault_address" => Ok(GeneratedField::VaultAddress), + "depositTx" | "deposit_tx" => Ok(GeneratedField::DepositTx), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DepositLog; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.DepositLog") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut txid__ = None; + let mut vault_address__ = None; + let mut deposit_tx__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Txid => { + if txid__.is_some() { + return Err(serde::de::Error::duplicate_field("txid")); + } + txid__ = Some(map_.next_value()?); + } + GeneratedField::VaultAddress => { + if vault_address__.is_some() { + return Err(serde::de::Error::duplicate_field("vaultAddress")); + } + vault_address__ = Some(map_.next_value()?); + } + GeneratedField::DepositTx => { + if deposit_tx__.is_some() { + return Err(serde::de::Error::duplicate_field("depositTx")); + } + deposit_tx__ = Some(map_.next_value()?); + } + } + } + Ok(DepositLog { + txid: txid__.unwrap_or_default(), + vault_address: vault_address__.unwrap_or_default(), + deposit_tx: deposit_tx__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.DepositLog", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for GenesisState { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.params.is_some() { + len += 1; + } + if !self.pools.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.GenesisState", len)?; + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + if !self.pools.is_empty() { + struct_ser.serialize_field("pools", &self.pools)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for GenesisState { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["params", "pools"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Params, + Pools, + } + #[cfg(feature = "serde")] + 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 { + "params" => Ok(GeneratedField::Params), + "pools" => Ok(GeneratedField::Pools), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GenesisState; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.GenesisState") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut params__ = None; + let mut pools__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map_.next_value()?; + } + GeneratedField::Pools => { + if pools__.is_some() { + return Err(serde::de::Error::duplicate_field("pools")); + } + pools__ = Some(map_.next_value()?); + } + } + } + Ok(GenesisState { + params: params__, + pools: pools__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.GenesisState", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for LendingPool { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.supply.is_some() { + len += 1; + } + if !self.total_shares.is_empty() { + len += 1; + } + if !self.borrowed_amount.is_empty() { + len += 1; + } + if self.status != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.LendingPool", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if let Some(v) = self.supply.as_ref() { + struct_ser.serialize_field("supply", v)?; + } + if !self.total_shares.is_empty() { + struct_ser.serialize_field("totalShares", &self.total_shares)?; + } + if !self.borrowed_amount.is_empty() { + struct_ser.serialize_field("borrowedAmount", &self.borrowed_amount)?; + } + if self.status != 0 { + let v = PoolStatus::try_from(self.status).map_err(|_| { + serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) + })?; + struct_ser.serialize_field("status", &v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for LendingPool { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "supply", + "total_shares", + "totalShares", + "borrowed_amount", + "borrowedAmount", + "status", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + Supply, + TotalShares, + BorrowedAmount, + Status, + } + #[cfg(feature = "serde")] + 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 { + "id" => Ok(GeneratedField::Id), + "supply" => Ok(GeneratedField::Supply), + "totalShares" | "total_shares" => Ok(GeneratedField::TotalShares), + "borrowedAmount" | "borrowed_amount" => { + Ok(GeneratedField::BorrowedAmount) + } + "status" => Ok(GeneratedField::Status), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LendingPool; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.LendingPool") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut supply__ = None; + let mut total_shares__ = None; + let mut borrowed_amount__ = None; + let mut status__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map_.next_value()?); + } + GeneratedField::Supply => { + if supply__.is_some() { + return Err(serde::de::Error::duplicate_field("supply")); + } + supply__ = map_.next_value()?; + } + GeneratedField::TotalShares => { + if total_shares__.is_some() { + return Err(serde::de::Error::duplicate_field("totalShares")); + } + total_shares__ = Some(map_.next_value()?); + } + GeneratedField::BorrowedAmount => { + if borrowed_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowedAmount")); + } + borrowed_amount__ = Some(map_.next_value()?); + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } + } + } + Ok(LendingPool { + id: id__.unwrap_or_default(), + supply: supply__, + total_shares: total_shares__.unwrap_or_default(), + borrowed_amount: borrowed_amount__.unwrap_or_default(), + status: status__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.LendingPool", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for Loan { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.vault_address.is_empty() { + len += 1; + } + if !self.borrower.is_empty() { + len += 1; + } + if !self.agency.is_empty() { + len += 1; + } + if !self.hash_loan_secret.is_empty() { + len += 1; + } + if self.maturity_time != 0 { + len += 1; + } + if self.final_timeout != 0 { + len += 1; + } + if self.borrow_amount.is_some() { + len += 1; + } + if !self.fees.is_empty() { + len += 1; + } + if !self.interests.is_empty() { + len += 1; + } + if !self.term.is_empty() { + len += 1; + } + if !self.event_id.is_empty() { + len += 1; + } + if !self.attestation_id.is_empty() { + len += 1; + } + if !self.deposit_txs.is_empty() { + len += 1; + } + if !self.collateral_amount.is_empty() { + len += 1; + } + if !self.loan_secret.is_empty() { + len += 1; + } + if self.create_at.is_some() { + len += 1; + } + if self.status != 0 { + len += 1; + } + if !self.pool_id.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.Loan", len)?; + if !self.vault_address.is_empty() { + struct_ser.serialize_field("vaultAddress", &self.vault_address)?; + } + if !self.borrower.is_empty() { + struct_ser.serialize_field("borrower", &self.borrower)?; + } + if !self.agency.is_empty() { + struct_ser.serialize_field("agency", &self.agency)?; + } + if !self.hash_loan_secret.is_empty() { + struct_ser.serialize_field("hashLoanSecret", &self.hash_loan_secret)?; + } + if self.maturity_time != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "maturityTime", + alloc::string::ToString::to_string(&self.maturity_time).as_str(), + )?; + } + if self.final_timeout != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "finalTimeout", + alloc::string::ToString::to_string(&self.final_timeout).as_str(), + )?; + } + if let Some(v) = self.borrow_amount.as_ref() { + struct_ser.serialize_field("borrowAmount", v)?; + } + if !self.fees.is_empty() { + struct_ser.serialize_field("fees", &self.fees)?; + } + if !self.interests.is_empty() { + struct_ser.serialize_field("interests", &self.interests)?; + } + if !self.term.is_empty() { + struct_ser.serialize_field("term", &self.term)?; + } + if !self.event_id.is_empty() { + struct_ser.serialize_field("eventId", &self.event_id)?; + } + if !self.attestation_id.is_empty() { + struct_ser.serialize_field("attestationId", &self.attestation_id)?; + } + if !self.deposit_txs.is_empty() { + struct_ser.serialize_field("depositTxs", &self.deposit_txs)?; + } + if !self.collateral_amount.is_empty() { + struct_ser.serialize_field("collateralAmount", &self.collateral_amount)?; + } + if !self.loan_secret.is_empty() { + struct_ser.serialize_field("loanSecret", &self.loan_secret)?; + } + if let Some(v) = self.create_at.as_ref() { + struct_ser.serialize_field("createAt", v)?; + } + if self.status != 0 { + let v = LoanStatus::try_from(self.status).map_err(|_| { + serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status)) + })?; + struct_ser.serialize_field("status", &v)?; + } + if !self.pool_id.is_empty() { + struct_ser.serialize_field("poolId", &self.pool_id)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for Loan { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "vault_address", + "vaultAddress", + "borrower", + "agency", + "hash_loan_secret", + "hashLoanSecret", + "maturity_time", + "maturityTime", + "final_timeout", + "finalTimeout", + "borrow_amount", + "borrowAmount", + "fees", + "interests", + "term", + "event_id", + "eventId", + "attestation_id", + "attestationId", + "deposit_txs", + "depositTxs", + "collateral_amount", + "collateralAmount", + "loan_secret", + "loanSecret", + "create_at", + "createAt", + "status", + "pool_id", + "poolId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + VaultAddress, + Borrower, + Agency, + HashLoanSecret, + MaturityTime, + FinalTimeout, + BorrowAmount, + Fees, + Interests, + Term, + EventId, + AttestationId, + DepositTxs, + CollateralAmount, + LoanSecret, + CreateAt, + Status, + PoolId, + } + #[cfg(feature = "serde")] + 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 { + "vaultAddress" | "vault_address" => Ok(GeneratedField::VaultAddress), + "borrower" => Ok(GeneratedField::Borrower), + "agency" => Ok(GeneratedField::Agency), + "hashLoanSecret" | "hash_loan_secret" => { + Ok(GeneratedField::HashLoanSecret) + } + "maturityTime" | "maturity_time" => Ok(GeneratedField::MaturityTime), + "finalTimeout" | "final_timeout" => Ok(GeneratedField::FinalTimeout), + "borrowAmount" | "borrow_amount" => Ok(GeneratedField::BorrowAmount), + "fees" => Ok(GeneratedField::Fees), + "interests" => Ok(GeneratedField::Interests), + "term" => Ok(GeneratedField::Term), + "eventId" | "event_id" => Ok(GeneratedField::EventId), + "attestationId" | "attestation_id" => Ok(GeneratedField::AttestationId), + "depositTxs" | "deposit_txs" => Ok(GeneratedField::DepositTxs), + "collateralAmount" | "collateral_amount" => { + Ok(GeneratedField::CollateralAmount) + } + "loanSecret" | "loan_secret" => Ok(GeneratedField::LoanSecret), + "createAt" | "create_at" => Ok(GeneratedField::CreateAt), + "status" => Ok(GeneratedField::Status), + "poolId" | "pool_id" => Ok(GeneratedField::PoolId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Loan; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.Loan") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut vault_address__ = None; + let mut borrower__ = None; + let mut agency__ = None; + let mut hash_loan_secret__ = None; + let mut maturity_time__ = None; + let mut final_timeout__ = None; + let mut borrow_amount__ = None; + let mut fees__ = None; + let mut interests__ = None; + let mut term__ = None; + let mut event_id__ = None; + let mut attestation_id__ = None; + let mut deposit_txs__ = None; + let mut collateral_amount__ = None; + let mut loan_secret__ = None; + let mut create_at__ = None; + let mut status__ = None; + let mut pool_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::VaultAddress => { + if vault_address__.is_some() { + return Err(serde::de::Error::duplicate_field("vaultAddress")); + } + vault_address__ = Some(map_.next_value()?); + } + GeneratedField::Borrower => { + if borrower__.is_some() { + return Err(serde::de::Error::duplicate_field("borrower")); + } + borrower__ = Some(map_.next_value()?); + } + GeneratedField::Agency => { + if agency__.is_some() { + return Err(serde::de::Error::duplicate_field("agency")); + } + agency__ = Some(map_.next_value()?); + } + GeneratedField::HashLoanSecret => { + if hash_loan_secret__.is_some() { + return Err(serde::de::Error::duplicate_field("hashLoanSecret")); + } + hash_loan_secret__ = Some(map_.next_value()?); + } + GeneratedField::MaturityTime => { + if maturity_time__.is_some() { + return Err(serde::de::Error::duplicate_field("maturityTime")); + } + maturity_time__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::FinalTimeout => { + if final_timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("finalTimeout")); + } + final_timeout__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::BorrowAmount => { + if borrow_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowAmount")); + } + borrow_amount__ = map_.next_value()?; + } + GeneratedField::Fees => { + if fees__.is_some() { + return Err(serde::de::Error::duplicate_field("fees")); + } + fees__ = Some(map_.next_value()?); + } + GeneratedField::Interests => { + if interests__.is_some() { + return Err(serde::de::Error::duplicate_field("interests")); + } + interests__ = Some(map_.next_value()?); + } + GeneratedField::Term => { + if term__.is_some() { + return Err(serde::de::Error::duplicate_field("term")); + } + term__ = Some(map_.next_value()?); + } + GeneratedField::EventId => { + if event_id__.is_some() { + return Err(serde::de::Error::duplicate_field("eventId")); + } + event_id__ = Some(map_.next_value()?); + } + GeneratedField::AttestationId => { + if attestation_id__.is_some() { + return Err(serde::de::Error::duplicate_field("attestationId")); + } + attestation_id__ = Some(map_.next_value()?); + } + GeneratedField::DepositTxs => { + if deposit_txs__.is_some() { + return Err(serde::de::Error::duplicate_field("depositTxs")); + } + deposit_txs__ = Some(map_.next_value()?); + } + GeneratedField::CollateralAmount => { + if collateral_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("collateralAmount")); + } + collateral_amount__ = Some(map_.next_value()?); + } + GeneratedField::LoanSecret => { + if loan_secret__.is_some() { + return Err(serde::de::Error::duplicate_field("loanSecret")); + } + loan_secret__ = Some(map_.next_value()?); + } + GeneratedField::CreateAt => { + if create_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createAt")); + } + create_at__ = map_.next_value()?; + } + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); + } + status__ = Some(map_.next_value::()? as i32); + } + GeneratedField::PoolId => { + if pool_id__.is_some() { + return Err(serde::de::Error::duplicate_field("poolId")); + } + pool_id__ = Some(map_.next_value()?); + } + } + } + Ok(Loan { + vault_address: vault_address__.unwrap_or_default(), + borrower: borrower__.unwrap_or_default(), + agency: agency__.unwrap_or_default(), + hash_loan_secret: hash_loan_secret__.unwrap_or_default(), + maturity_time: maturity_time__.unwrap_or_default(), + final_timeout: final_timeout__.unwrap_or_default(), + borrow_amount: borrow_amount__, + fees: fees__.unwrap_or_default(), + interests: interests__.unwrap_or_default(), + term: term__.unwrap_or_default(), + event_id: event_id__.unwrap_or_default(), + attestation_id: attestation_id__.unwrap_or_default(), + deposit_txs: deposit_txs__.unwrap_or_default(), + collateral_amount: collateral_amount__.unwrap_or_default(), + loan_secret: loan_secret__.unwrap_or_default(), + create_at: create_at__, + status: status__.unwrap_or_default(), + pool_id: pool_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.Loan", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for LoanStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Apply => "Apply", + Self::Approve => "Approve", + Self::Disburse => "Disburse", + Self::Repay => "Repay", + Self::Default => "Default", + Self::Liquidate => "Liquidate", + Self::Close => "Close", + }; + serializer.serialize_str(variant) + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for LoanStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Apply", + "Approve", + "Disburse", + "Repay", + "Default", + "Liquidate", + "Close", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LoanStatus; + + 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 { + "Apply" => Ok(LoanStatus::Apply), + "Approve" => Ok(LoanStatus::Approve), + "Disburse" => Ok(LoanStatus::Disburse), + "Repay" => Ok(LoanStatus::Repay), + "Default" => Ok(LoanStatus::Default), + "Liquidate" => Ok(LoanStatus::Liquidate), + "Close" => Ok(LoanStatus::Close), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgAddLiquidity { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.pool_id.is_empty() { + len += 1; + } + if !self.lender.is_empty() { + len += 1; + } + if self.amount.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgAddLiquidity", len)?; + if !self.pool_id.is_empty() { + struct_ser.serialize_field("poolId", &self.pool_id)?; + } + if !self.lender.is_empty() { + struct_ser.serialize_field("lender", &self.lender)?; + } + if let Some(v) = self.amount.as_ref() { + struct_ser.serialize_field("amount", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgAddLiquidity { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["pool_id", "poolId", "lender", "amount"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PoolId, + Lender, + Amount, + } + #[cfg(feature = "serde")] + 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 { + "poolId" | "pool_id" => Ok(GeneratedField::PoolId), + "lender" => Ok(GeneratedField::Lender), + "amount" => Ok(GeneratedField::Amount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgAddLiquidity; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgAddLiquidity") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut pool_id__ = None; + let mut lender__ = None; + let mut amount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::PoolId => { + if pool_id__.is_some() { + return Err(serde::de::Error::duplicate_field("poolId")); + } + pool_id__ = Some(map_.next_value()?); + } + GeneratedField::Lender => { + if lender__.is_some() { + return Err(serde::de::Error::duplicate_field("lender")); + } + lender__ = Some(map_.next_value()?); + } + GeneratedField::Amount => { + if amount__.is_some() { + return Err(serde::de::Error::duplicate_field("amount")); + } + amount__ = map_.next_value()?; + } + } + } + Ok(MsgAddLiquidity { + pool_id: pool_id__.unwrap_or_default(), + lender: lender__.unwrap_or_default(), + amount: amount__, + }) + } + } + deserializer.deserialize_struct("side.lending.MsgAddLiquidity", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgAddLiquidityResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.shares.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.MsgAddLiquidityResponse", len)?; + if let Some(v) = self.shares.as_ref() { + struct_ser.serialize_field("shares", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgAddLiquidityResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["shares"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Shares, + } + #[cfg(feature = "serde")] + 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 { + "shares" => Ok(GeneratedField::Shares), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgAddLiquidityResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgAddLiquidityResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut shares__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Shares => { + if shares__.is_some() { + return Err(serde::de::Error::duplicate_field("shares")); + } + shares__ = map_.next_value()?; + } + } + } + Ok(MsgAddLiquidityResponse { shares: shares__ }) + } + } + deserializer.deserialize_struct( + "side.lending.MsgAddLiquidityResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgApply { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.borrower.is_empty() { + len += 1; + } + if !self.borrower_pubkey.is_empty() { + len += 1; + } + if !self.loan_secret_hash.is_empty() { + len += 1; + } + if self.maturity_time != 0 { + len += 1; + } + if self.final_timeout != 0 { + len += 1; + } + if !self.pool_id.is_empty() { + len += 1; + } + if self.borrow_amount.is_some() { + len += 1; + } + if !self.event_id.is_empty() { + len += 1; + } + if !self.cets.is_empty() { + len += 1; + } + if !self.deposit_tx.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgApply", len)?; + if !self.borrower.is_empty() { + struct_ser.serialize_field("borrower", &self.borrower)?; + } + if !self.borrower_pubkey.is_empty() { + struct_ser.serialize_field("borrowerPubkey", &self.borrower_pubkey)?; + } + if !self.loan_secret_hash.is_empty() { + struct_ser.serialize_field("loanSecretHash", &self.loan_secret_hash)?; + } + if self.maturity_time != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "maturityTime", + alloc::string::ToString::to_string(&self.maturity_time).as_str(), + )?; + } + if self.final_timeout != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "finalTimeout", + alloc::string::ToString::to_string(&self.final_timeout).as_str(), + )?; + } + if !self.pool_id.is_empty() { + struct_ser.serialize_field("poolId", &self.pool_id)?; + } + if let Some(v) = self.borrow_amount.as_ref() { + struct_ser.serialize_field("borrowAmount", v)?; + } + if !self.event_id.is_empty() { + struct_ser.serialize_field("eventId", &self.event_id)?; + } + if !self.cets.is_empty() { + struct_ser.serialize_field("cets", &self.cets)?; + } + if !self.deposit_tx.is_empty() { + struct_ser.serialize_field("depositTx", &self.deposit_tx)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgApply { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "borrower", + "borrower_pubkey", + "borrowerPubkey", + "loan_secret_hash", + "loanSecretHash", + "maturity_time", + "maturityTime", + "final_timeout", + "finalTimeout", + "pool_id", + "poolId", + "borrow_amount", + "borrowAmount", + "event_id", + "eventId", + "cets", + "deposit_tx", + "depositTx", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Borrower, + BorrowerPubkey, + LoanSecretHash, + MaturityTime, + FinalTimeout, + PoolId, + BorrowAmount, + EventId, + Cets, + DepositTx, + } + #[cfg(feature = "serde")] + 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 { + "borrower" => Ok(GeneratedField::Borrower), + "borrowerPubkey" | "borrower_pubkey" => { + Ok(GeneratedField::BorrowerPubkey) + } + "loanSecretHash" | "loan_secret_hash" => { + Ok(GeneratedField::LoanSecretHash) + } + "maturityTime" | "maturity_time" => Ok(GeneratedField::MaturityTime), + "finalTimeout" | "final_timeout" => Ok(GeneratedField::FinalTimeout), + "poolId" | "pool_id" => Ok(GeneratedField::PoolId), + "borrowAmount" | "borrow_amount" => Ok(GeneratedField::BorrowAmount), + "eventId" | "event_id" => Ok(GeneratedField::EventId), + "cets" => Ok(GeneratedField::Cets), + "depositTx" | "deposit_tx" => Ok(GeneratedField::DepositTx), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgApply; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgApply") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut borrower__ = None; + let mut borrower_pubkey__ = None; + let mut loan_secret_hash__ = None; + let mut maturity_time__ = None; + let mut final_timeout__ = None; + let mut pool_id__ = None; + let mut borrow_amount__ = None; + let mut event_id__ = None; + let mut cets__ = None; + let mut deposit_tx__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Borrower => { + if borrower__.is_some() { + return Err(serde::de::Error::duplicate_field("borrower")); + } + borrower__ = Some(map_.next_value()?); + } + GeneratedField::BorrowerPubkey => { + if borrower_pubkey__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowerPubkey")); + } + borrower_pubkey__ = Some(map_.next_value()?); + } + GeneratedField::LoanSecretHash => { + if loan_secret_hash__.is_some() { + return Err(serde::de::Error::duplicate_field("loanSecretHash")); + } + loan_secret_hash__ = Some(map_.next_value()?); + } + GeneratedField::MaturityTime => { + if maturity_time__.is_some() { + return Err(serde::de::Error::duplicate_field("maturityTime")); + } + maturity_time__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::FinalTimeout => { + if final_timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("finalTimeout")); + } + final_timeout__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::PoolId => { + if pool_id__.is_some() { + return Err(serde::de::Error::duplicate_field("poolId")); + } + pool_id__ = Some(map_.next_value()?); + } + GeneratedField::BorrowAmount => { + if borrow_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowAmount")); + } + borrow_amount__ = map_.next_value()?; + } + GeneratedField::EventId => { + if event_id__.is_some() { + return Err(serde::de::Error::duplicate_field("eventId")); + } + event_id__ = Some(map_.next_value()?); + } + GeneratedField::Cets => { + if cets__.is_some() { + return Err(serde::de::Error::duplicate_field("cets")); + } + cets__ = Some(map_.next_value()?); + } + GeneratedField::DepositTx => { + if deposit_tx__.is_some() { + return Err(serde::de::Error::duplicate_field("depositTx")); + } + deposit_tx__ = Some(map_.next_value()?); + } + } + } + Ok(MsgApply { + borrower: borrower__.unwrap_or_default(), + borrower_pubkey: borrower_pubkey__.unwrap_or_default(), + loan_secret_hash: loan_secret_hash__.unwrap_or_default(), + maturity_time: maturity_time__.unwrap_or_default(), + final_timeout: final_timeout__.unwrap_or_default(), + pool_id: pool_id__.unwrap_or_default(), + borrow_amount: borrow_amount__, + event_id: event_id__.unwrap_or_default(), + cets: cets__.unwrap_or_default(), + deposit_tx: deposit_tx__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgApply", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgApplyResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.vault_address.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgApplyResponse", len)?; + if !self.vault_address.is_empty() { + struct_ser.serialize_field("vaultAddress", &self.vault_address)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgApplyResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["vault_address", "vaultAddress"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + VaultAddress, + } + #[cfg(feature = "serde")] + 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 { + "vaultAddress" | "vault_address" => Ok(GeneratedField::VaultAddress), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgApplyResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgApplyResponse") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut vault_address__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::VaultAddress => { + if vault_address__.is_some() { + return Err(serde::de::Error::duplicate_field("vaultAddress")); + } + vault_address__ = Some(map_.next_value()?); + } + } + } + Ok(MsgApplyResponse { + vault_address: vault_address__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgApplyResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgApprove { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.relayer.is_empty() { + len += 1; + } + if !self.deposit_tx_id.is_empty() { + len += 1; + } + if self.height != 0 { + len += 1; + } + if !self.poof.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgApprove", len)?; + if !self.relayer.is_empty() { + struct_ser.serialize_field("relayer", &self.relayer)?; + } + if !self.deposit_tx_id.is_empty() { + struct_ser.serialize_field("depositTxId", &self.deposit_tx_id)?; + } + if self.height != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "height", + alloc::string::ToString::to_string(&self.height).as_str(), + )?; + } + if !self.poof.is_empty() { + struct_ser.serialize_field("poof", &self.poof)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgApprove { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["relayer", "deposit_tx_id", "depositTxId", "height", "poof"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Relayer, + DepositTxId, + Height, + Poof, + } + #[cfg(feature = "serde")] + 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 { + "relayer" => Ok(GeneratedField::Relayer), + "depositTxId" | "deposit_tx_id" => Ok(GeneratedField::DepositTxId), + "height" => Ok(GeneratedField::Height), + "poof" => Ok(GeneratedField::Poof), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgApprove; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgApprove") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut relayer__ = None; + let mut deposit_tx_id__ = None; + let mut height__ = None; + let mut poof__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Relayer => { + if relayer__.is_some() { + return Err(serde::de::Error::duplicate_field("relayer")); + } + relayer__ = Some(map_.next_value()?); + } + GeneratedField::DepositTxId => { + if deposit_tx_id__.is_some() { + return Err(serde::de::Error::duplicate_field("depositTxId")); + } + deposit_tx_id__ = Some(map_.next_value()?); + } + GeneratedField::Height => { + if height__.is_some() { + return Err(serde::de::Error::duplicate_field("height")); + } + height__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::Poof => { + if poof__.is_some() { + return Err(serde::de::Error::duplicate_field("poof")); + } + poof__ = Some(map_.next_value()?); + } + } + } + Ok(MsgApprove { + relayer: relayer__.unwrap_or_default(), + deposit_tx_id: deposit_tx_id__.unwrap_or_default(), + height: height__.unwrap_or_default(), + poof: poof__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgApprove", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgApproveResponse { + #[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("side.lending.MsgApproveResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgApproveResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgApproveResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgApproveResponse") + } + + 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(MsgApproveResponse {}) + } + } + deserializer.deserialize_struct("side.lending.MsgApproveResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgClose { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.relayer.is_empty() { + len += 1; + } + if !self.loan_id.is_empty() { + len += 1; + } + if !self.signature.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgClose", len)?; + if !self.relayer.is_empty() { + struct_ser.serialize_field("relayer", &self.relayer)?; + } + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + if !self.signature.is_empty() { + struct_ser.serialize_field("signature", &self.signature)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgClose { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["relayer", "loan_id", "loanId", "signature"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Relayer, + LoanId, + Signature, + } + #[cfg(feature = "serde")] + 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 { + "relayer" => Ok(GeneratedField::Relayer), + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + "signature" => Ok(GeneratedField::Signature), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgClose; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgClose") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut relayer__ = None; + let mut loan_id__ = None; + let mut signature__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Relayer => { + if relayer__.is_some() { + return Err(serde::de::Error::duplicate_field("relayer")); + } + relayer__ = Some(map_.next_value()?); + } + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = Some(map_.next_value()?); + } + } + } + Ok(MsgClose { + relayer: relayer__.unwrap_or_default(), + loan_id: loan_id__.unwrap_or_default(), + signature: signature__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgClose", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgCloseResponse { + #[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("side.lending.MsgCloseResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgCloseResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgCloseResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgCloseResponse") + } + + 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(MsgCloseResponse {}) + } + } + deserializer.deserialize_struct("side.lending.MsgCloseResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgCreatePool { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.creator.is_empty() { + len += 1; + } + if !self.pool_id.is_empty() { + len += 1; + } + if !self.lending_asset.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgCreatePool", len)?; + if !self.creator.is_empty() { + struct_ser.serialize_field("creator", &self.creator)?; + } + if !self.pool_id.is_empty() { + struct_ser.serialize_field("poolId", &self.pool_id)?; + } + if !self.lending_asset.is_empty() { + struct_ser.serialize_field("lendingAsset", &self.lending_asset)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgCreatePool { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "creator", + "pool_id", + "poolId", + "lending_asset", + "lendingAsset", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Creator, + PoolId, + LendingAsset, + } + #[cfg(feature = "serde")] + 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 { + "creator" => Ok(GeneratedField::Creator), + "poolId" | "pool_id" => Ok(GeneratedField::PoolId), + "lendingAsset" | "lending_asset" => Ok(GeneratedField::LendingAsset), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgCreatePool; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgCreatePool") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut creator__ = None; + let mut pool_id__ = None; + let mut lending_asset__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Creator => { + if creator__.is_some() { + return Err(serde::de::Error::duplicate_field("creator")); + } + creator__ = Some(map_.next_value()?); + } + GeneratedField::PoolId => { + if pool_id__.is_some() { + return Err(serde::de::Error::duplicate_field("poolId")); + } + pool_id__ = Some(map_.next_value()?); + } + GeneratedField::LendingAsset => { + if lending_asset__.is_some() { + return Err(serde::de::Error::duplicate_field("lendingAsset")); + } + lending_asset__ = Some(map_.next_value()?); + } + } + } + Ok(MsgCreatePool { + creator: creator__.unwrap_or_default(), + pool_id: pool_id__.unwrap_or_default(), + lending_asset: lending_asset__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgCreatePool", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgCreatePoolResponse { + #[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("side.lending.MsgCreatePoolResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgCreatePoolResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgCreatePoolResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgCreatePoolResponse") + } + + 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(MsgCreatePoolResponse {}) + } + } + deserializer.deserialize_struct( + "side.lending.MsgCreatePoolResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRedeem { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.borrower.is_empty() { + len += 1; + } + if !self.loan_id.is_empty() { + len += 1; + } + if !self.loan_secret.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgRedeem", len)?; + if !self.borrower.is_empty() { + struct_ser.serialize_field("borrower", &self.borrower)?; + } + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + if !self.loan_secret.is_empty() { + struct_ser.serialize_field("loanSecret", &self.loan_secret)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRedeem { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["borrower", "loan_id", "loanId", "loan_secret", "loanSecret"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Borrower, + LoanId, + LoanSecret, + } + #[cfg(feature = "serde")] + 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 { + "borrower" => Ok(GeneratedField::Borrower), + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + "loanSecret" | "loan_secret" => Ok(GeneratedField::LoanSecret), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgRedeem; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRedeem") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut borrower__ = None; + let mut loan_id__ = None; + let mut loan_secret__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Borrower => { + if borrower__.is_some() { + return Err(serde::de::Error::duplicate_field("borrower")); + } + borrower__ = Some(map_.next_value()?); + } + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + GeneratedField::LoanSecret => { + if loan_secret__.is_some() { + return Err(serde::de::Error::duplicate_field("loanSecret")); + } + loan_secret__ = Some(map_.next_value()?); + } + } + } + Ok(MsgRedeem { + borrower: borrower__.unwrap_or_default(), + loan_id: loan_id__.unwrap_or_default(), + loan_secret: loan_secret__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgRedeem", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRedeemResponse { + #[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("side.lending.MsgRedeemResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRedeemResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgRedeemResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRedeemResponse") + } + + 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(MsgRedeemResponse {}) + } + } + deserializer.deserialize_struct("side.lending.MsgRedeemResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRemoveLiquidity { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.lender.is_empty() { + len += 1; + } + if self.shares.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgRemoveLiquidity", len)?; + if !self.lender.is_empty() { + struct_ser.serialize_field("lender", &self.lender)?; + } + if let Some(v) = self.shares.as_ref() { + struct_ser.serialize_field("shares", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRemoveLiquidity { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["lender", "shares"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Lender, + Shares, + } + #[cfg(feature = "serde")] + 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 { + "lender" => Ok(GeneratedField::Lender), + "shares" => Ok(GeneratedField::Shares), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgRemoveLiquidity; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRemoveLiquidity") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut lender__ = None; + let mut shares__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Lender => { + if lender__.is_some() { + return Err(serde::de::Error::duplicate_field("lender")); + } + lender__ = Some(map_.next_value()?); + } + GeneratedField::Shares => { + if shares__.is_some() { + return Err(serde::de::Error::duplicate_field("shares")); + } + shares__ = map_.next_value()?; + } + } + } + Ok(MsgRemoveLiquidity { + lender: lender__.unwrap_or_default(), + shares: shares__, + }) + } + } + deserializer.deserialize_struct("side.lending.MsgRemoveLiquidity", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRemoveLiquidityResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.amount.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.MsgRemoveLiquidityResponse", len)?; + if let Some(v) = self.amount.as_ref() { + struct_ser.serialize_field("amount", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRemoveLiquidityResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["amount"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Amount, + } + #[cfg(feature = "serde")] + 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 { + "amount" => Ok(GeneratedField::Amount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgRemoveLiquidityResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRemoveLiquidityResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut amount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Amount => { + if amount__.is_some() { + return Err(serde::de::Error::duplicate_field("amount")); + } + amount__ = map_.next_value()?; + } + } + } + Ok(MsgRemoveLiquidityResponse { amount: amount__ }) + } + } + deserializer.deserialize_struct( + "side.lending.MsgRemoveLiquidityResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRepay { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.borrower.is_empty() { + len += 1; + } + if !self.loan_id.is_empty() { + len += 1; + } + if !self.adaptor_point.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.MsgRepay", len)?; + if !self.borrower.is_empty() { + struct_ser.serialize_field("borrower", &self.borrower)?; + } + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + if !self.adaptor_point.is_empty() { + struct_ser.serialize_field("adaptorPoint", &self.adaptor_point)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRepay { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "borrower", + "loan_id", + "loanId", + "adaptor_point", + "adaptorPoint", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Borrower, + LoanId, + AdaptorPoint, + } + #[cfg(feature = "serde")] + 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 { + "borrower" => Ok(GeneratedField::Borrower), + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + "adaptorPoint" | "adaptor_point" => Ok(GeneratedField::AdaptorPoint), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MsgRepay; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRepay") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut borrower__ = None; + let mut loan_id__ = None; + let mut adaptor_point__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Borrower => { + if borrower__.is_some() { + return Err(serde::de::Error::duplicate_field("borrower")); + } + borrower__ = Some(map_.next_value()?); + } + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + GeneratedField::AdaptorPoint => { + if adaptor_point__.is_some() { + return Err(serde::de::Error::duplicate_field("adaptorPoint")); + } + adaptor_point__ = Some(map_.next_value()?); + } + } + } + Ok(MsgRepay { + borrower: borrower__.unwrap_or_default(), + loan_id: loan_id__.unwrap_or_default(), + adaptor_point: adaptor_point__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.MsgRepay", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for MsgRepayResponse { + #[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("side.lending.MsgRepayResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for MsgRepayResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = MsgRepayResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.MsgRepayResponse") + } + + 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(MsgRepayResponse {}) + } + } + deserializer.deserialize_struct("side.lending.MsgRepayResponse", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +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 !self.supply_rate_permille.is_empty() { + len += 1; + } + if !self.borrow_rate_permille.is_empty() { + len += 1; + } + if !self.fee_recipient.is_empty() { + len += 1; + } + if !self.pool_creators.is_empty() { + len += 1; + } + if !self.min_initial_ltv_percent.is_empty() { + len += 1; + } + if !self.liquidation_threshold_percent.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.Params", len)?; + if !self.supply_rate_permille.is_empty() { + struct_ser.serialize_field("supplyRatePermille", &self.supply_rate_permille)?; + } + if !self.borrow_rate_permille.is_empty() { + struct_ser.serialize_field("borrowRatePermille", &self.borrow_rate_permille)?; + } + if !self.fee_recipient.is_empty() { + struct_ser.serialize_field("feeRecipient", &self.fee_recipient)?; + } + if !self.pool_creators.is_empty() { + struct_ser.serialize_field("poolCreators", &self.pool_creators)?; + } + if !self.min_initial_ltv_percent.is_empty() { + struct_ser.serialize_field("minInitialLtvPercent", &self.min_initial_ltv_percent)?; + } + if !self.liquidation_threshold_percent.is_empty() { + struct_ser.serialize_field( + "liquidationThresholdPercent", + &self.liquidation_threshold_percent, + )?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for Params { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "supply_rate_permille", + "supplyRatePermille", + "borrow_rate_permille", + "borrowRatePermille", + "fee_recipient", + "feeRecipient", + "pool_creators", + "poolCreators", + "min_initial_ltv_percent", + "minInitialLtvPercent", + "liquidation_threshold_percent", + "liquidationThresholdPercent", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SupplyRatePermille, + BorrowRatePermille, + FeeRecipient, + PoolCreators, + MinInitialLtvPercent, + LiquidationThresholdPercent, + } + #[cfg(feature = "serde")] + 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 { + "supplyRatePermille" | "supply_rate_permille" => { + Ok(GeneratedField::SupplyRatePermille) + } + "borrowRatePermille" | "borrow_rate_permille" => { + Ok(GeneratedField::BorrowRatePermille) + } + "feeRecipient" | "fee_recipient" => Ok(GeneratedField::FeeRecipient), + "poolCreators" | "pool_creators" => Ok(GeneratedField::PoolCreators), + "minInitialLtvPercent" | "min_initial_ltv_percent" => { + Ok(GeneratedField::MinInitialLtvPercent) + } + "liquidationThresholdPercent" | "liquidation_threshold_percent" => { + Ok(GeneratedField::LiquidationThresholdPercent) + } + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Params; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.Params") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut supply_rate_permille__ = None; + let mut borrow_rate_permille__ = None; + let mut fee_recipient__ = None; + let mut pool_creators__ = None; + let mut min_initial_ltv_percent__ = None; + let mut liquidation_threshold_percent__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::SupplyRatePermille => { + if supply_rate_permille__.is_some() { + return Err(serde::de::Error::duplicate_field( + "supplyRatePermille", + )); + } + supply_rate_permille__ = Some(map_.next_value()?); + } + GeneratedField::BorrowRatePermille => { + if borrow_rate_permille__.is_some() { + return Err(serde::de::Error::duplicate_field( + "borrowRatePermille", + )); + } + borrow_rate_permille__ = Some(map_.next_value()?); + } + GeneratedField::FeeRecipient => { + if fee_recipient__.is_some() { + return Err(serde::de::Error::duplicate_field("feeRecipient")); + } + fee_recipient__ = Some(map_.next_value()?); + } + GeneratedField::PoolCreators => { + if pool_creators__.is_some() { + return Err(serde::de::Error::duplicate_field("poolCreators")); + } + pool_creators__ = Some(map_.next_value()?); + } + GeneratedField::MinInitialLtvPercent => { + if min_initial_ltv_percent__.is_some() { + return Err(serde::de::Error::duplicate_field( + "minInitialLtvPercent", + )); + } + min_initial_ltv_percent__ = Some(map_.next_value()?); + } + GeneratedField::LiquidationThresholdPercent => { + if liquidation_threshold_percent__.is_some() { + return Err(serde::de::Error::duplicate_field( + "liquidationThresholdPercent", + )); + } + liquidation_threshold_percent__ = Some(map_.next_value()?); + } + } + } + Ok(Params { + supply_rate_permille: supply_rate_permille__.unwrap_or_default(), + borrow_rate_permille: borrow_rate_permille__.unwrap_or_default(), + fee_recipient: fee_recipient__.unwrap_or_default(), + pool_creators: pool_creators__.unwrap_or_default(), + min_initial_ltv_percent: min_initial_ltv_percent__.unwrap_or_default(), + liquidation_threshold_percent: liquidation_threshold_percent__ + .unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("side.lending.Params", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for PoolStatus { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Active => "ACTIVE", + Self::Inactive => "INACTIVE", + }; + serializer.serialize_str(variant) + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for PoolStatus { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["ACTIVE", "INACTIVE"]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PoolStatus; + + 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 { + "ACTIVE" => Ok(PoolStatus::Active), + "INACTIVE" => Ok(PoolStatus::Inactive), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryCollateralAddressRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.borrower_pubkey.is_empty() { + len += 1; + } + if !self.hash_of_loan_secret.is_empty() { + len += 1; + } + if self.maturity_time != 0 { + len += 1; + } + if self.final_timeout != 0 { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryCollateralAddressRequest", len)?; + if !self.borrower_pubkey.is_empty() { + struct_ser.serialize_field("borrowerPubkey", &self.borrower_pubkey)?; + } + if !self.hash_of_loan_secret.is_empty() { + struct_ser.serialize_field("hashOfLoanSecret", &self.hash_of_loan_secret)?; + } + if self.maturity_time != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "maturityTime", + alloc::string::ToString::to_string(&self.maturity_time).as_str(), + )?; + } + if self.final_timeout != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field( + "finalTimeout", + alloc::string::ToString::to_string(&self.final_timeout).as_str(), + )?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryCollateralAddressRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "borrower_pubkey", + "borrowerPubkey", + "hash_of_loan_secret", + "hashOfLoanSecret", + "maturity_time", + "maturityTime", + "final_timeout", + "finalTimeout", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + BorrowerPubkey, + HashOfLoanSecret, + MaturityTime, + FinalTimeout, + } + #[cfg(feature = "serde")] + 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 { + "borrowerPubkey" | "borrower_pubkey" => { + Ok(GeneratedField::BorrowerPubkey) + } + "hashOfLoanSecret" | "hash_of_loan_secret" => { + Ok(GeneratedField::HashOfLoanSecret) + } + "maturityTime" | "maturity_time" => Ok(GeneratedField::MaturityTime), + "finalTimeout" | "final_timeout" => Ok(GeneratedField::FinalTimeout), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryCollateralAddressRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryCollateralAddressRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut borrower_pubkey__ = None; + let mut hash_of_loan_secret__ = None; + let mut maturity_time__ = None; + let mut final_timeout__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::BorrowerPubkey => { + if borrower_pubkey__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowerPubkey")); + } + borrower_pubkey__ = Some(map_.next_value()?); + } + GeneratedField::HashOfLoanSecret => { + if hash_of_loan_secret__.is_some() { + return Err(serde::de::Error::duplicate_field("hashOfLoanSecret")); + } + hash_of_loan_secret__ = Some(map_.next_value()?); + } + GeneratedField::MaturityTime => { + if maturity_time__.is_some() { + return Err(serde::de::Error::duplicate_field("maturityTime")); + } + maturity_time__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + GeneratedField::FinalTimeout => { + if final_timeout__.is_some() { + return Err(serde::de::Error::duplicate_field("finalTimeout")); + } + final_timeout__ = Some( + map_.next_value::<::pbjson::private::NumberDeserialize<_>>()? + .0, + ); + } + } + } + Ok(QueryCollateralAddressRequest { + borrower_pubkey: borrower_pubkey__.unwrap_or_default(), + hash_of_loan_secret: hash_of_loan_secret__.unwrap_or_default(), + maturity_time: maturity_time__.unwrap_or_default(), + final_timeout: final_timeout__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryCollateralAddressRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryCollateralAddressResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.address.is_empty() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryCollateralAddressResponse", len)?; + if !self.address.is_empty() { + struct_ser.serialize_field("address", &self.address)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryCollateralAddressResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["address"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Address, + } + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 { + "address" => Ok(GeneratedField::Address), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryCollateralAddressResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryCollateralAddressResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut address__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Address => { + if address__.is_some() { + return Err(serde::de::Error::duplicate_field("address")); + } + address__ = Some(map_.next_value()?); + } + } + } + Ok(QueryCollateralAddressResponse { + address: address__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryCollateralAddressResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryLiquidationEventRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.borrow_amount.is_some() { + len += 1; + } + if self.collateral_acmount.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryLiquidationEventRequest", len)?; + if let Some(v) = self.borrow_amount.as_ref() { + struct_ser.serialize_field("borrowAmount", v)?; + } + if let Some(v) = self.collateral_acmount.as_ref() { + struct_ser.serialize_field("collateralAcmount", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryLiquidationEventRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "borrow_amount", + "borrowAmount", + "collateral_acmount", + "collateralAcmount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + BorrowAmount, + CollateralAcmount, + } + #[cfg(feature = "serde")] + 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 { + "borrowAmount" | "borrow_amount" => Ok(GeneratedField::BorrowAmount), + "collateralAcmount" | "collateral_acmount" => { + Ok(GeneratedField::CollateralAcmount) + } + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryLiquidationEventRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryLiquidationEventRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut borrow_amount__ = None; + let mut collateral_acmount__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::BorrowAmount => { + if borrow_amount__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowAmount")); + } + borrow_amount__ = map_.next_value()?; + } + GeneratedField::CollateralAcmount => { + if collateral_acmount__.is_some() { + return Err(serde::de::Error::duplicate_field("collateralAcmount")); + } + collateral_acmount__ = map_.next_value()?; + } + } + } + Ok(QueryLiquidationEventRequest { + borrow_amount: borrow_amount__, + collateral_acmount: collateral_acmount__, + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryLiquidationEventRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryLiquidationEventResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.event_id.is_empty() { + len += 1; + } + if !self.oracle_pubkey.is_empty() { + len += 1; + } + if !self.nonce.is_empty() { + len += 1; + } + if !self.price.is_empty() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryLiquidationEventResponse", len)?; + if !self.event_id.is_empty() { + struct_ser.serialize_field("eventId", &self.event_id)?; + } + if !self.oracle_pubkey.is_empty() { + struct_ser.serialize_field("oraclePubkey", &self.oracle_pubkey)?; + } + if !self.nonce.is_empty() { + struct_ser.serialize_field("nonce", &self.nonce)?; + } + if !self.price.is_empty() { + struct_ser.serialize_field("price", &self.price)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryLiquidationEventResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "event_id", + "eventId", + "oracle_pubkey", + "oraclePubkey", + "nonce", + "price", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EventId, + OraclePubkey, + Nonce, + Price, + } + #[cfg(feature = "serde")] + 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 { + "eventId" | "event_id" => Ok(GeneratedField::EventId), + "oraclePubkey" | "oracle_pubkey" => Ok(GeneratedField::OraclePubkey), + "nonce" => Ok(GeneratedField::Nonce), + "price" => Ok(GeneratedField::Price), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryLiquidationEventResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryLiquidationEventResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut event_id__ = None; + let mut oracle_pubkey__ = None; + let mut nonce__ = None; + let mut price__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::EventId => { + if event_id__.is_some() { + return Err(serde::de::Error::duplicate_field("eventId")); + } + event_id__ = Some(map_.next_value()?); + } + GeneratedField::OraclePubkey => { + if oracle_pubkey__.is_some() { + return Err(serde::de::Error::duplicate_field("oraclePubkey")); + } + oracle_pubkey__ = Some(map_.next_value()?); + } + GeneratedField::Nonce => { + if nonce__.is_some() { + return Err(serde::de::Error::duplicate_field("nonce")); + } + nonce__ = Some(map_.next_value()?); + } + GeneratedField::Price => { + if price__.is_some() { + return Err(serde::de::Error::duplicate_field("price")); + } + price__ = Some(map_.next_value()?); + } + } + } + Ok(QueryLiquidationEventResponse { + event_id: event_id__.unwrap_or_default(), + oracle_pubkey: oracle_pubkey__.unwrap_or_default(), + nonce: nonce__.unwrap_or_default(), + price: price__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryLiquidationEventResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryLoanCetRequest { + #[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("side.lending.QueryLoanCETRequest", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryLoanCetRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = QueryLoanCetRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryLoanCETRequest") + } + + 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(QueryLoanCetRequest {}) + } + } + deserializer.deserialize_struct( + "side.lending.QueryLoanCETRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryLoanCetResponse { + #[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("side.lending.QueryLoanCETResponse", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryLoanCetResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = QueryLoanCetResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryLoanCETResponse") + } + + 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(QueryLoanCetResponse {}) + } + } + deserializer.deserialize_struct( + "side.lending.QueryLoanCETResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryParamsRequest { + #[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("side.lending.QueryParamsRequest", len)?; + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryParamsRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField {} + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 = QueryParamsRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryParamsRequest") + } + + 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(QueryParamsRequest {}) + } + } + deserializer.deserialize_struct("side.lending.QueryParamsRequest", FIELDS, GeneratedVisitor) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryParamsResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.params.is_some() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryParamsResponse", len)?; + if let Some(v) = self.params.as_ref() { + struct_ser.serialize_field("params", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryParamsResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["params"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Params, + } + #[cfg(feature = "serde")] + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(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 { + "params" => Ok(GeneratedField::Params), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryParamsResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryParamsResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut params__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Params => { + if params__.is_some() { + return Err(serde::de::Error::duplicate_field("params")); + } + params__ = map_.next_value()?; + } + } + } + Ok(QueryParamsResponse { params: params__ }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryParamsResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryRepaymentTxRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.loan_id.is_empty() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryRepaymentTxRequest", len)?; + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryRepaymentTxRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["loan_id", "loanId"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LoanId, + } + #[cfg(feature = "serde")] + 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 { + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryRepaymentTxRequest; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryRepaymentTxRequest") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut loan_id__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + } + } + Ok(QueryRepaymentTxRequest { + loan_id: loan_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryRepaymentTxRequest", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for QueryRepaymentTxResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.claim_tx.is_empty() { + len += 1; + } + let mut struct_ser = + serializer.serialize_struct("side.lending.QueryRepaymentTxResponse", len)?; + if !self.claim_tx.is_empty() { + struct_ser.serialize_field("claimTx", &self.claim_tx)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for QueryRepaymentTxResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &["claim_tx", "claimTx"]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ClaimTx, + } + #[cfg(feature = "serde")] + 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 { + "claimTx" | "claim_tx" => Ok(GeneratedField::ClaimTx), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryRepaymentTxResponse; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.QueryRepaymentTxResponse") + } + + fn visit_map( + self, + mut map_: V, + ) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut claim_tx__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::ClaimTx => { + if claim_tx__.is_some() { + return Err(serde::de::Error::duplicate_field("claimTx")); + } + claim_tx__ = Some(map_.next_value()?); + } + } + } + Ok(QueryRepaymentTxResponse { + claim_tx: claim_tx__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct( + "side.lending.QueryRepaymentTxResponse", + FIELDS, + GeneratedVisitor, + ) + } +} +#[cfg(feature = "serde")] +impl serde::Serialize for Repayment { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> core::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.loan_id.is_empty() { + len += 1; + } + if !self.txid.is_empty() { + len += 1; + } + if !self.tx.is_empty() { + len += 1; + } + if !self.repay_adaptor_point.is_empty() { + len += 1; + } + if !self.borrower_signature.is_empty() { + len += 1; + } + if self.create_at.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("side.lending.Repayment", len)?; + if !self.loan_id.is_empty() { + struct_ser.serialize_field("loanId", &self.loan_id)?; + } + if !self.txid.is_empty() { + struct_ser.serialize_field("txid", &self.txid)?; + } + if !self.tx.is_empty() { + struct_ser.serialize_field("tx", &self.tx)?; + } + if !self.repay_adaptor_point.is_empty() { + struct_ser.serialize_field("repayAdaptorPoint", &self.repay_adaptor_point)?; + } + if !self.borrower_signature.is_empty() { + struct_ser.serialize_field("borrowerSignature", &self.borrower_signature)?; + } + if let Some(v) = self.create_at.as_ref() { + struct_ser.serialize_field("createAt", v)?; + } + struct_ser.end() + } +} +#[cfg(feature = "serde")] +impl<'de> serde::Deserialize<'de> for Repayment { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> core::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "loan_id", + "loanId", + "txid", + "tx", + "repay_adaptor_point", + "repayAdaptorPoint", + "borrower_signature", + "borrowerSignature", + "create_at", + "createAt", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + LoanId, + Txid, + Tx, + RepayAdaptorPoint, + BorrowerSignature, + CreateAt, + } + #[cfg(feature = "serde")] + 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 { + "loanId" | "loan_id" => Ok(GeneratedField::LoanId), + "txid" => Ok(GeneratedField::Txid), + "tx" => Ok(GeneratedField::Tx), + "repayAdaptorPoint" | "repay_adaptor_point" => { + Ok(GeneratedField::RepayAdaptorPoint) + } + "borrowerSignature" | "borrower_signature" => { + Ok(GeneratedField::BorrowerSignature) + } + "createAt" | "create_at" => Ok(GeneratedField::CreateAt), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Repayment; + + fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + formatter.write_str("struct side.lending.Repayment") + } + + fn visit_map(self, mut map_: V) -> core::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut loan_id__ = None; + let mut txid__ = None; + let mut tx__ = None; + let mut repay_adaptor_point__ = None; + let mut borrower_signature__ = None; + let mut create_at__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::LoanId => { + if loan_id__.is_some() { + return Err(serde::de::Error::duplicate_field("loanId")); + } + loan_id__ = Some(map_.next_value()?); + } + GeneratedField::Txid => { + if txid__.is_some() { + return Err(serde::de::Error::duplicate_field("txid")); + } + txid__ = Some(map_.next_value()?); + } + GeneratedField::Tx => { + if tx__.is_some() { + return Err(serde::de::Error::duplicate_field("tx")); + } + tx__ = Some(map_.next_value()?); + } + GeneratedField::RepayAdaptorPoint => { + if repay_adaptor_point__.is_some() { + return Err(serde::de::Error::duplicate_field("repayAdaptorPoint")); + } + repay_adaptor_point__ = Some(map_.next_value()?); + } + GeneratedField::BorrowerSignature => { + if borrower_signature__.is_some() { + return Err(serde::de::Error::duplicate_field("borrowerSignature")); + } + borrower_signature__ = Some(map_.next_value()?); + } + GeneratedField::CreateAt => { + if create_at__.is_some() { + return Err(serde::de::Error::duplicate_field("createAt")); + } + create_at__ = map_.next_value()?; + } + } + } + Ok(Repayment { + loan_id: loan_id__.unwrap_or_default(), + txid: txid__.unwrap_or_default(), + tx: tx__.unwrap_or_default(), + repay_adaptor_point: repay_adaptor_point__.unwrap_or_default(), + borrower_signature: borrower_signature__.unwrap_or_default(), + create_at: create_at__, + }) + } + } + deserializer.deserialize_struct("side.lending.Repayment", FIELDS, GeneratedVisitor) + } +} diff --git a/side-proto/src/prost/side/side.lending.tonic.rs b/side-proto/src/prost/side/side.lending.tonic.rs new file mode 100644 index 0000000..d008b99 --- /dev/null +++ b/side-proto/src/prost/side/side.lending.tonic.rs @@ -0,0 +1,1213 @@ +// @generated +/// Generated client implementations. +#[cfg(feature = "grpc")] +pub mod query_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::http::Uri; + use tonic::codegen::*; + #[derive(Debug, Clone)] + pub struct QueryClient { + inner: tonic::client::Grpc, + } + #[cfg(feature = "grpc-transport")] + impl QueryClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl QueryClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> QueryClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + >>::Error: + Into + Send + Sync, + { + QueryClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn params( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Query/Params"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Query", "Params")); + self.inner.unary(req, path, codec).await + } + pub async fn collateral_address( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = + http::uri::PathAndQuery::from_static("/side.lending.Query/CollateralAddress"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Query", "CollateralAddress")); + self.inner.unary(req, path, codec).await + } + pub async fn liquidation_event( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LiquidationEvent"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Query", "LiquidationEvent")); + self.inner.unary(req, path, codec).await + } + pub async fn loan_cet( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Query/LoanCET"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Query", "LoanCET")); + self.inner.unary(req, path, codec).await + } + pub async fn unsigned_payment_tx( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = + http::uri::PathAndQuery::from_static("/side.lending.Query/UnsignedPaymentTx"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Query", "UnsignedPaymentTx")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "grpc")] +pub mod query_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with QueryServer. + #[async_trait] + pub trait Query: Send + Sync + 'static { + async fn params( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn collateral_address( + &self, + request: tonic::Request, + ) -> core::result::Result< + tonic::Response, + tonic::Status, + >; + async fn liquidation_event( + &self, + request: tonic::Request, + ) -> core::result::Result< + tonic::Response, + tonic::Status, + >; + async fn loan_cet( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn unsigned_payment_tx( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct QueryServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl QueryServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for QueryServer + where + T: Query, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/side.lending.Query/Params" => { + #[allow(non_camel_case_types)] + struct ParamsSvc(pub Arc); + impl tonic::server::UnaryService for ParamsSvc { + type Response = super::QueryParamsResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).params(request).await }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ParamsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/side.lending.Query/CollateralAddress" => { + #[allow(non_camel_case_types)] + struct CollateralAddressSvc(pub Arc); + impl tonic::server::UnaryService + for CollateralAddressSvc + { + type Response = super::QueryCollateralAddressResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).collateral_address(request).await }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = CollateralAddressSvc(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) + } + "/side.lending.Query/LiquidationEvent" => { + #[allow(non_camel_case_types)] + struct LiquidationEventSvc(pub Arc); + impl tonic::server::UnaryService + for LiquidationEventSvc + { + type Response = super::QueryLiquidationEventResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).liquidation_event(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 = LiquidationEventSvc(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) + } + "/side.lending.Query/LoanCET" => { + #[allow(non_camel_case_types)] + struct LoanCETSvc(pub Arc); + impl tonic::server::UnaryService for LoanCETSvc { + type Response = super::QueryLoanCetResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).loan_cet(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 = LoanCETSvc(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) + } + "/side.lending.Query/UnsignedPaymentTx" => { + #[allow(non_camel_case_types)] + struct UnsignedPaymentTxSvc(pub Arc); + impl tonic::server::UnaryService + for UnsignedPaymentTxSvc + { + type Response = super::QueryRepaymentTxResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).unsigned_payment_tx(request).await }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnsignedPaymentTxSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => Box::pin(async move { + Ok(http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap()) + }), + } + } + } + impl Clone for QueryServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl core::fmt::Debug for _Inner { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for QueryServer { + const NAME: &'static str = "side.lending.Query"; + } +} +/// Generated client implementations. +#[cfg(feature = "grpc")] +pub mod msg_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::http::Uri; + use tonic::codegen::*; + #[derive(Debug, Clone)] + pub struct MsgClient { + inner: tonic::client::Grpc, + } + #[cfg(feature = "grpc-transport")] + 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 + } + pub async fn create_pool( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/CreatePool"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "CreatePool")); + self.inner.unary(req, path, codec).await + } + pub async fn add_liquidity( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/AddLiquidity"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "AddLiquidity")); + self.inner.unary(req, path, codec).await + } + pub async fn remove_liquidity( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/RemoveLiquidity"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "RemoveLiquidity")); + self.inner.unary(req, path, codec).await + } + pub async fn apply( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Apply"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "Apply")); + self.inner.unary(req, path, codec).await + } + pub async fn approve( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Approve"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "Approve")); + self.inner.unary(req, path, codec).await + } + pub async fn redeem( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> + { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Redeem"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "Redeem")); + self.inner.unary(req, path, codec).await + } + pub async fn repay( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Repay"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "Repay")); + self.inner.unary(req, path, codec).await + } + pub async fn close( + &mut self, + request: impl tonic::IntoRequest, + ) -> core::result::Result, tonic::Status> { + self.inner.ready().await.map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + alloc::format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static("/side.lending.Msg/Close"); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("side.lending.Msg", "Close")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +#[cfg(feature = "grpc")] +pub mod msg_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with MsgServer. + #[async_trait] + pub trait Msg: Send + Sync + 'static { + async fn create_pool( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn add_liquidity( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn remove_liquidity( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn apply( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn approve( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn redeem( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn repay( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + async fn close( + &self, + request: tonic::Request, + ) -> core::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct MsgServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl MsgServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for MsgServer + where + T: Msg, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/side.lending.Msg/CreatePool" => { + #[allow(non_camel_case_types)] + struct CreatePoolSvc(pub Arc); + impl tonic::server::UnaryService for CreatePoolSvc { + type Response = super::MsgCreatePoolResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).create_pool(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 = CreatePoolSvc(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) + } + "/side.lending.Msg/AddLiquidity" => { + #[allow(non_camel_case_types)] + struct AddLiquiditySvc(pub Arc); + impl tonic::server::UnaryService for AddLiquiditySvc { + type Response = super::MsgAddLiquidityResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).add_liquidity(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 = AddLiquiditySvc(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) + } + "/side.lending.Msg/RemoveLiquidity" => { + #[allow(non_camel_case_types)] + struct RemoveLiquiditySvc(pub Arc); + impl tonic::server::UnaryService for RemoveLiquiditySvc { + type Response = super::MsgRemoveLiquidityResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).remove_liquidity(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 = RemoveLiquiditySvc(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) + } + "/side.lending.Msg/Apply" => { + #[allow(non_camel_case_types)] + struct ApplySvc(pub Arc); + impl tonic::server::UnaryService for ApplySvc { + type Response = super::MsgApplyResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).apply(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 = ApplySvc(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) + } + "/side.lending.Msg/Approve" => { + #[allow(non_camel_case_types)] + struct ApproveSvc(pub Arc); + impl tonic::server::UnaryService for ApproveSvc { + type Response = super::MsgApproveResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).approve(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 = ApproveSvc(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) + } + "/side.lending.Msg/Redeem" => { + #[allow(non_camel_case_types)] + struct RedeemSvc(pub Arc); + impl tonic::server::UnaryService for RedeemSvc { + type Response = super::MsgRedeemResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).redeem(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 = RedeemSvc(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) + } + "/side.lending.Msg/Repay" => { + #[allow(non_camel_case_types)] + struct RepaySvc(pub Arc); + impl tonic::server::UnaryService for RepaySvc { + type Response = super::MsgRepayResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).repay(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 = RepaySvc(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) + } + "/side.lending.Msg/Close" => { + #[allow(non_camel_case_types)] + struct CloseSvc(pub Arc); + impl tonic::server::UnaryService for CloseSvc { + type Response = super::MsgCloseResponse; + type Future = BoxFuture, tonic::Status>; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { (*inner).close(request).await }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = CloseSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => Box::pin(async move { + Ok(http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap()) + }), + } + } + } + impl Clone for MsgServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl core::fmt::Debug for _Inner { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for MsgServer { + const NAME: &'static str = "side.lending.Msg"; + } +}