impl serde::Serialize for ClientState {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.ClientState", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
}
if true {
struct_ser.serialize_field("isFrozen", &self.is_frozen)?;
}
if let Some(v) = self.consensus_state.as_ref() {
struct_ser.serialize_field("consensusState", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ClientState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"sequence",
"is_frozen",
"isFrozen",
"consensus_state",
"consensusState",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sequence,
IsFrozen,
ConsensusState,
}
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 {
"sequence" => Ok(GeneratedField::Sequence),
"isFrozen" | "is_frozen" => Ok(GeneratedField::IsFrozen),
"consensusState" | "consensus_state" => Ok(GeneratedField::ConsensusState),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ClientState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.ClientState")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut sequence__ = None;
let mut is_frozen__ = None;
let mut consensus_state__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Sequence => {
if sequence__.is_some() {
return Err(serde::de::Error::duplicate_field("sequence"));
}
sequence__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::IsFrozen => {
if is_frozen__.is_some() {
return Err(serde::de::Error::duplicate_field("isFrozen"));
}
is_frozen__ = Some(map_.next_value()?);
}
GeneratedField::ConsensusState => {
if consensus_state__.is_some() {
return Err(serde::de::Error::duplicate_field("consensusState"));
}
consensus_state__ = map_.next_value()?;
}
}
}
Ok(ClientState {
sequence: sequence__.unwrap_or_default(),
is_frozen: is_frozen__.unwrap_or_default(),
consensus_state: consensus_state__,
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.ClientState", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ConsensusState {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.ConsensusState", len)?;
if let Some(v) = self.public_key.as_ref() {
struct_ser.serialize_field("publicKey", v)?;
}
if true {
struct_ser.serialize_field("diversifier", &self.diversifier)?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ConsensusState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"public_key",
"publicKey",
"diversifier",
"timestamp",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PublicKey,
Diversifier,
Timestamp,
}
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 {
"publicKey" | "public_key" => Ok(GeneratedField::PublicKey),
"diversifier" => Ok(GeneratedField::Diversifier),
"timestamp" => Ok(GeneratedField::Timestamp),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ConsensusState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.ConsensusState")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut public_key__ = None;
let mut diversifier__ = None;
let mut timestamp__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PublicKey => {
if public_key__.is_some() {
return Err(serde::de::Error::duplicate_field("publicKey"));
}
public_key__ = map_.next_value()?;
}
GeneratedField::Diversifier => {
if diversifier__.is_some() {
return Err(serde::de::Error::duplicate_field("diversifier"));
}
diversifier__ = Some(map_.next_value()?);
}
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(ConsensusState {
public_key: public_key__,
diversifier: diversifier__.unwrap_or_default(),
timestamp: timestamp__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.ConsensusState", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Header {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.Header", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
}
if let Some(v) = self.new_public_key.as_ref() {
struct_ser.serialize_field("newPublicKey", v)?;
}
if true {
struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Header {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"signature",
"new_public_key",
"newPublicKey",
"new_diversifier",
"newDiversifier",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Signature,
NewPublicKey,
NewDiversifier,
}
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 {
"timestamp" => Ok(GeneratedField::Timestamp),
"signature" => Ok(GeneratedField::Signature),
"newPublicKey" | "new_public_key" => Ok(GeneratedField::NewPublicKey),
"newDiversifier" | "new_diversifier" => Ok(GeneratedField::NewDiversifier),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Header;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.Header")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Header, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut signature__ = None;
let mut new_public_key__ = None;
let mut new_diversifier__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Signature => {
if signature__.is_some() {
return Err(serde::de::Error::duplicate_field("signature"));
}
signature__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::NewPublicKey => {
if new_public_key__.is_some() {
return Err(serde::de::Error::duplicate_field("newPublicKey"));
}
new_public_key__ = map_.next_value()?;
}
GeneratedField::NewDiversifier => {
if new_diversifier__.is_some() {
return Err(serde::de::Error::duplicate_field("newDiversifier"));
}
new_diversifier__ = Some(map_.next_value()?);
}
}
}
Ok(Header {
timestamp: timestamp__.unwrap_or_default(),
signature: signature__.unwrap_or_default(),
new_public_key: new_public_key__,
new_diversifier: new_diversifier__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.Header", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for HeaderData {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.HeaderData", len)?;
if let Some(v) = self.new_pub_key.as_ref() {
struct_ser.serialize_field("newPubKey", v)?;
}
if true {
struct_ser.serialize_field("newDiversifier", &self.new_diversifier)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for HeaderData {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"new_pub_key",
"newPubKey",
"new_diversifier",
"newDiversifier",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
NewPubKey,
NewDiversifier,
}
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 {
"newPubKey" | "new_pub_key" => Ok(GeneratedField::NewPubKey),
"newDiversifier" | "new_diversifier" => Ok(GeneratedField::NewDiversifier),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = HeaderData;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.HeaderData")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<HeaderData, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut new_pub_key__ = None;
let mut new_diversifier__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::NewPubKey => {
if new_pub_key__.is_some() {
return Err(serde::de::Error::duplicate_field("newPubKey"));
}
new_pub_key__ = map_.next_value()?;
}
GeneratedField::NewDiversifier => {
if new_diversifier__.is_some() {
return Err(serde::de::Error::duplicate_field("newDiversifier"));
}
new_diversifier__ = Some(map_.next_value()?);
}
}
}
Ok(HeaderData {
new_pub_key: new_pub_key__,
new_diversifier: new_diversifier__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.HeaderData", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Misbehaviour {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.Misbehaviour", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
}
if let Some(v) = self.signature_one.as_ref() {
struct_ser.serialize_field("signatureOne", v)?;
}
if let Some(v) = self.signature_two.as_ref() {
struct_ser.serialize_field("signatureTwo", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Misbehaviour {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"sequence",
"signature_one",
"signatureOne",
"signature_two",
"signatureTwo",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sequence,
SignatureOne,
SignatureTwo,
}
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 {
"sequence" => Ok(GeneratedField::Sequence),
"signatureOne" | "signature_one" => Ok(GeneratedField::SignatureOne),
"signatureTwo" | "signature_two" => Ok(GeneratedField::SignatureTwo),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Misbehaviour;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.Misbehaviour")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Misbehaviour, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut sequence__ = None;
let mut signature_one__ = None;
let mut signature_two__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Sequence => {
if sequence__.is_some() {
return Err(serde::de::Error::duplicate_field("sequence"));
}
sequence__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::SignatureOne => {
if signature_one__.is_some() {
return Err(serde::de::Error::duplicate_field("signatureOne"));
}
signature_one__ = map_.next_value()?;
}
GeneratedField::SignatureTwo => {
if signature_two__.is_some() {
return Err(serde::de::Error::duplicate_field("signatureTwo"));
}
signature_two__ = map_.next_value()?;
}
}
}
Ok(Misbehaviour {
sequence: sequence__.unwrap_or_default(),
signature_one: signature_one__,
signature_two: signature_two__,
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.Misbehaviour", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for SignBytes {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.SignBytes", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
}
if true {
struct_ser.serialize_field("diversifier", &self.diversifier)?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SignBytes {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"sequence",
"timestamp",
"diversifier",
"path",
"data",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sequence,
Timestamp,
Diversifier,
Path,
Data,
}
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 {
"sequence" => Ok(GeneratedField::Sequence),
"timestamp" => Ok(GeneratedField::Timestamp),
"diversifier" => Ok(GeneratedField::Diversifier),
"path" => Ok(GeneratedField::Path),
"data" => Ok(GeneratedField::Data),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SignBytes;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.SignBytes")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignBytes, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut sequence__ = None;
let mut timestamp__ = None;
let mut diversifier__ = None;
let mut path__ = None;
let mut data__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Sequence => {
if sequence__.is_some() {
return Err(serde::de::Error::duplicate_field("sequence"));
}
sequence__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Diversifier => {
if diversifier__.is_some() {
return Err(serde::de::Error::duplicate_field("diversifier"));
}
diversifier__ = Some(map_.next_value()?);
}
GeneratedField::Path => {
if path__.is_some() {
return Err(serde::de::Error::duplicate_field("path"));
}
path__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Data => {
if data__.is_some() {
return Err(serde::de::Error::duplicate_field("data"));
}
data__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
}
}
Ok(SignBytes {
sequence: sequence__.unwrap_or_default(),
timestamp: timestamp__.unwrap_or_default(),
diversifier: diversifier__.unwrap_or_default(),
path: path__.unwrap_or_default(),
data: data__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.SignBytes", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for SignatureAndData {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.SignatureAndData", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SignatureAndData {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signature",
"path",
"data",
"timestamp",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Signature,
Path,
Data,
Timestamp,
}
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 {
"signature" => Ok(GeneratedField::Signature),
"path" => Ok(GeneratedField::Path),
"data" => Ok(GeneratedField::Data),
"timestamp" => Ok(GeneratedField::Timestamp),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SignatureAndData;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.SignatureAndData")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignatureAndData, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut signature__ = None;
let mut path__ = None;
let mut data__ = None;
let mut timestamp__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Signature => {
if signature__.is_some() {
return Err(serde::de::Error::duplicate_field("signature"));
}
signature__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Path => {
if path__.is_some() {
return Err(serde::de::Error::duplicate_field("path"));
}
path__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Data => {
if data__.is_some() {
return Err(serde::de::Error::duplicate_field("data"));
}
data__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(SignatureAndData {
signature: signature__.unwrap_or_default(),
path: path__.unwrap_or_default(),
data: data__.unwrap_or_default(),
timestamp: timestamp__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.SignatureAndData", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TimestampedSignatureData {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.TimestampedSignatureData", len)?;
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("signatureData", pbjson::private::base64::encode(&self.signature_data).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signature_data",
"signatureData",
"timestamp",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
SignatureData,
Timestamp,
}
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 {
"signatureData" | "signature_data" => Ok(GeneratedField::SignatureData),
"timestamp" => Ok(GeneratedField::Timestamp),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TimestampedSignatureData;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.solomachine.v3.TimestampedSignatureData")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<TimestampedSignatureData, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut signature_data__ = None;
let mut timestamp__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::SignatureData => {
if signature_data__.is_some() {
return Err(serde::de::Error::duplicate_field("signatureData"));
}
signature_data__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(TimestampedSignatureData {
signature_data: signature_data__.unwrap_or_default(),
timestamp: timestamp__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.solomachine.v3.TimestampedSignatureData", FIELDS, GeneratedVisitor)
}
}