#[cfg(feature = "serde")]
impl serde::Serialize for GenesisState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.params.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.incentive.GenesisState", 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 GenesisState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["params"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GenesisState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.GenesisState")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
}
}
Ok(GenesisState { params: params__ })
}
}
deserializer.deserialize_struct("side.incentive.GenesisState", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgUpdateParams {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
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.incentive.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<D>(deserializer: D) -> core::result::Result<Self, D::Error>
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<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
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.incentive.MsgUpdateParams")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
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.incentive.MsgUpdateParams", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgUpdateParamsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser =
serializer.serialize_struct("side.incentive.MsgUpdateParamsResponse", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgUpdateParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.MsgUpdateParamsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(MsgUpdateParamsResponse {})
}
}
deserializer.deserialize_struct(
"side.incentive.MsgUpdateParamsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Params {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.enabled {
len += 1;
}
if self.reward_per_deposit.is_some() {
len += 1;
}
if self.reward_per_withdraw.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.incentive.Params", len)?;
if self.enabled {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
if let Some(v) = self.reward_per_deposit.as_ref() {
struct_ser.serialize_field("rewardPerDeposit", v)?;
}
if let Some(v) = self.reward_per_withdraw.as_ref() {
struct_ser.serialize_field("rewardPerWithdraw", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Params {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"enabled",
"reward_per_deposit",
"rewardPerDeposit",
"reward_per_withdraw",
"rewardPerWithdraw",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Enabled,
RewardPerDeposit,
RewardPerWithdraw,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"enabled" => Ok(GeneratedField::Enabled),
"rewardPerDeposit" | "reward_per_deposit" => {
Ok(GeneratedField::RewardPerDeposit)
}
"rewardPerWithdraw" | "reward_per_withdraw" => {
Ok(GeneratedField::RewardPerWithdraw)
}
_ => 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.incentive.Params")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut enabled__ = None;
let mut reward_per_deposit__ = None;
let mut reward_per_withdraw__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Enabled => {
if enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("enabled"));
}
enabled__ = Some(map_.next_value()?);
}
GeneratedField::RewardPerDeposit => {
if reward_per_deposit__.is_some() {
return Err(serde::de::Error::duplicate_field("rewardPerDeposit"));
}
reward_per_deposit__ = map_.next_value()?;
}
GeneratedField::RewardPerWithdraw => {
if reward_per_withdraw__.is_some() {
return Err(serde::de::Error::duplicate_field("rewardPerWithdraw"));
}
reward_per_withdraw__ = map_.next_value()?;
}
}
}
Ok(Params {
enabled: enabled__.unwrap_or_default(),
reward_per_deposit: reward_per_deposit__,
reward_per_withdraw: reward_per_withdraw__,
})
}
}
deserializer.deserialize_struct("side.incentive.Params", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryParamsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("side.incentive.QueryParamsRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryParamsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryParamsRequest")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryParamsRequest {})
}
}
deserializer.deserialize_struct(
"side.incentive.QueryParamsRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryParamsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.params.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.incentive.QueryParamsResponse", len)?;
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["params"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryParamsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryParamsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
}
}
Ok(QueryParamsResponse { params: params__ })
}
}
deserializer.deserialize_struct(
"side.incentive.QueryParamsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryRewardStatsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser =
serializer.serialize_struct("side.incentive.QueryRewardStatsRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryRewardStatsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryRewardStatsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryRewardStatsRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryRewardStatsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryRewardStatsRequest {})
}
}
deserializer.deserialize_struct(
"side.incentive.QueryRewardStatsRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryRewardStatsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.reward_stats.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.incentive.QueryRewardStatsResponse", len)?;
if let Some(v) = self.reward_stats.as_ref() {
struct_ser.serialize_field("rewardStats", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryRewardStatsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["reward_stats", "rewardStats"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
RewardStats,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"rewardStats" | "reward_stats" => Ok(GeneratedField::RewardStats),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryRewardStatsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryRewardStatsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryRewardStatsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut reward_stats__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::RewardStats => {
if reward_stats__.is_some() {
return Err(serde::de::Error::duplicate_field("rewardStats"));
}
reward_stats__ = map_.next_value()?;
}
}
}
Ok(QueryRewardStatsResponse {
reward_stats: reward_stats__,
})
}
}
deserializer.deserialize_struct(
"side.incentive.QueryRewardStatsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryRewardsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.address.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.incentive.QueryRewardsRequest", 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 QueryRewardsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["address"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Address,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"address" => Ok(GeneratedField::Address),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryRewardsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryRewardsRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryRewardsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut address__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Address => {
if address__.is_some() {
return Err(serde::de::Error::duplicate_field("address"));
}
address__ = Some(map_.next_value()?);
}
}
}
Ok(QueryRewardsRequest {
address: address__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.incentive.QueryRewardsRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryRewardsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.rewards.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.incentive.QueryRewardsResponse", len)?;
if let Some(v) = self.rewards.as_ref() {
struct_ser.serialize_field("rewards", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryRewardsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["rewards"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Rewards,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"rewards" => Ok(GeneratedField::Rewards),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryRewardsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.QueryRewardsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryRewardsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut rewards__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Rewards => {
if rewards__.is_some() {
return Err(serde::de::Error::duplicate_field("rewards"));
}
rewards__ = map_.next_value()?;
}
}
}
Ok(QueryRewardsResponse { rewards: rewards__ })
}
}
deserializer.deserialize_struct(
"side.incentive.QueryRewardsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for RewardStats {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.address_count != 0 {
len += 1;
}
if self.tx_count != 0 {
len += 1;
}
if self.total_reward_amount.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.incentive.RewardStats", len)?;
if self.address_count != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"addressCount",
alloc::string::ToString::to_string(&self.address_count).as_str(),
)?;
}
if self.tx_count != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"txCount",
alloc::string::ToString::to_string(&self.tx_count).as_str(),
)?;
}
if let Some(v) = self.total_reward_amount.as_ref() {
struct_ser.serialize_field("totalRewardAmount", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for RewardStats {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"address_count",
"addressCount",
"tx_count",
"txCount",
"total_reward_amount",
"totalRewardAmount",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
AddressCount,
TxCount,
TotalRewardAmount,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"addressCount" | "address_count" => Ok(GeneratedField::AddressCount),
"txCount" | "tx_count" => Ok(GeneratedField::TxCount),
"totalRewardAmount" | "total_reward_amount" => {
Ok(GeneratedField::TotalRewardAmount)
}
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = RewardStats;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.RewardStats")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<RewardStats, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut address_count__ = None;
let mut tx_count__ = None;
let mut total_reward_amount__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::AddressCount => {
if address_count__.is_some() {
return Err(serde::de::Error::duplicate_field("addressCount"));
}
address_count__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::TxCount => {
if tx_count__.is_some() {
return Err(serde::de::Error::duplicate_field("txCount"));
}
tx_count__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::TotalRewardAmount => {
if total_reward_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("totalRewardAmount"));
}
total_reward_amount__ = map_.next_value()?;
}
}
}
Ok(RewardStats {
address_count: address_count__.unwrap_or_default(),
tx_count: tx_count__.unwrap_or_default(),
total_reward_amount: total_reward_amount__,
})
}
}
deserializer.deserialize_struct("side.incentive.RewardStats", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Rewards {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.address.is_empty() {
len += 1;
}
if self.deposit_count != 0 {
len += 1;
}
if self.withdraw_count != 0 {
len += 1;
}
if self.deposit_reward.is_some() {
len += 1;
}
if self.withdraw_reward.is_some() {
len += 1;
}
if self.total_amount.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.incentive.Rewards", len)?;
if !self.address.is_empty() {
struct_ser.serialize_field("address", &self.address)?;
}
if self.deposit_count != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"depositCount",
alloc::string::ToString::to_string(&self.deposit_count).as_str(),
)?;
}
if self.withdraw_count != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"withdrawCount",
alloc::string::ToString::to_string(&self.withdraw_count).as_str(),
)?;
}
if let Some(v) = self.deposit_reward.as_ref() {
struct_ser.serialize_field("depositReward", v)?;
}
if let Some(v) = self.withdraw_reward.as_ref() {
struct_ser.serialize_field("withdrawReward", v)?;
}
if let Some(v) = self.total_amount.as_ref() {
struct_ser.serialize_field("totalAmount", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Rewards {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"address",
"deposit_count",
"depositCount",
"withdraw_count",
"withdrawCount",
"deposit_reward",
"depositReward",
"withdraw_reward",
"withdrawReward",
"total_amount",
"totalAmount",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Address,
DepositCount,
WithdrawCount,
DepositReward,
WithdrawReward,
TotalAmount,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
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<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"address" => Ok(GeneratedField::Address),
"depositCount" | "deposit_count" => Ok(GeneratedField::DepositCount),
"withdrawCount" | "withdraw_count" => Ok(GeneratedField::WithdrawCount),
"depositReward" | "deposit_reward" => Ok(GeneratedField::DepositReward),
"withdrawReward" | "withdraw_reward" => {
Ok(GeneratedField::WithdrawReward)
}
"totalAmount" | "total_amount" => Ok(GeneratedField::TotalAmount),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Rewards;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.incentive.Rewards")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Rewards, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut address__ = None;
let mut deposit_count__ = None;
let mut withdraw_count__ = None;
let mut deposit_reward__ = None;
let mut withdraw_reward__ = None;
let mut total_amount__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Address => {
if address__.is_some() {
return Err(serde::de::Error::duplicate_field("address"));
}
address__ = Some(map_.next_value()?);
}
GeneratedField::DepositCount => {
if deposit_count__.is_some() {
return Err(serde::de::Error::duplicate_field("depositCount"));
}
deposit_count__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::WithdrawCount => {
if withdraw_count__.is_some() {
return Err(serde::de::Error::duplicate_field("withdrawCount"));
}
withdraw_count__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::DepositReward => {
if deposit_reward__.is_some() {
return Err(serde::de::Error::duplicate_field("depositReward"));
}
deposit_reward__ = map_.next_value()?;
}
GeneratedField::WithdrawReward => {
if withdraw_reward__.is_some() {
return Err(serde::de::Error::duplicate_field("withdrawReward"));
}
withdraw_reward__ = map_.next_value()?;
}
GeneratedField::TotalAmount => {
if total_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("totalAmount"));
}
total_amount__ = map_.next_value()?;
}
}
}
Ok(Rewards {
address: address__.unwrap_or_default(),
deposit_count: deposit_count__.unwrap_or_default(),
withdraw_count: withdraw_count__.unwrap_or_default(),
deposit_reward: deposit_reward__,
withdraw_reward: withdraw_reward__,
total_amount: total_amount__,
})
}
}
deserializer.deserialize_struct("side.incentive.Rewards", FIELDS, GeneratedVisitor)
}
}