#[cfg(feature = "serde")]
impl serde::Serialize for BlockHeader {
#[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.version != 0 {
len += 1;
}
if !self.hash.is_empty() {
len += 1;
}
if self.height != 0 {
len += 1;
}
if !self.previous_block_hash.is_empty() {
len += 1;
}
if !self.merkle_root.is_empty() {
len += 1;
}
if self.nonce != 0 {
len += 1;
}
if !self.bits.is_empty() {
len += 1;
}
if self.time != 0 {
len += 1;
}
if self.ntx != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.oracle.BlockHeader", len)?;
if self.version != 0 {
struct_ser.serialize_field("version", &self.version)?;
}
if !self.hash.is_empty() {
struct_ser.serialize_field("hash", &self.hash)?;
}
if self.height != 0 {
struct_ser.serialize_field("height", &self.height)?;
}
if !self.previous_block_hash.is_empty() {
struct_ser.serialize_field("previousBlockHash", &self.previous_block_hash)?;
}
if !self.merkle_root.is_empty() {
struct_ser.serialize_field("merkleRoot", &self.merkle_root)?;
}
if self.nonce != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"nonce",
alloc::string::ToString::to_string(&self.nonce).as_str(),
)?;
}
if !self.bits.is_empty() {
struct_ser.serialize_field("bits", &self.bits)?;
}
if self.time != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"time",
alloc::string::ToString::to_string(&self.time).as_str(),
)?;
}
if self.ntx != 0 {
struct_ser.serialize_field("ntx", &self.ntx)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for BlockHeader {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"version",
"hash",
"height",
"previous_block_hash",
"previousBlockHash",
"merkle_root",
"merkleRoot",
"nonce",
"bits",
"time",
"ntx",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Version,
Hash,
Height,
PreviousBlockHash,
MerkleRoot,
Nonce,
Bits,
Time,
Ntx,
}
#[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 {
"version" => Ok(GeneratedField::Version),
"hash" => Ok(GeneratedField::Hash),
"height" => Ok(GeneratedField::Height),
"previousBlockHash" | "previous_block_hash" => {
Ok(GeneratedField::PreviousBlockHash)
}
"merkleRoot" | "merkle_root" => Ok(GeneratedField::MerkleRoot),
"nonce" => Ok(GeneratedField::Nonce),
"bits" => Ok(GeneratedField::Bits),
"time" => Ok(GeneratedField::Time),
"ntx" => Ok(GeneratedField::Ntx),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BlockHeader;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.BlockHeader")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<BlockHeader, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut version__ = None;
let mut hash__ = None;
let mut height__ = None;
let mut previous_block_hash__ = None;
let mut merkle_root__ = None;
let mut nonce__ = None;
let mut bits__ = None;
let mut time__ = None;
let mut ntx__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Version => {
if version__.is_some() {
return Err(serde::de::Error::duplicate_field("version"));
}
version__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Hash => {
if hash__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
hash__ = 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::PreviousBlockHash => {
if previous_block_hash__.is_some() {
return Err(serde::de::Error::duplicate_field("previousBlockHash"));
}
previous_block_hash__ = Some(map_.next_value()?);
}
GeneratedField::MerkleRoot => {
if merkle_root__.is_some() {
return Err(serde::de::Error::duplicate_field("merkleRoot"));
}
merkle_root__ = Some(map_.next_value()?);
}
GeneratedField::Nonce => {
if nonce__.is_some() {
return Err(serde::de::Error::duplicate_field("nonce"));
}
nonce__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Bits => {
if bits__.is_some() {
return Err(serde::de::Error::duplicate_field("bits"));
}
bits__ = Some(map_.next_value()?);
}
GeneratedField::Time => {
if time__.is_some() {
return Err(serde::de::Error::duplicate_field("time"));
}
time__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Ntx => {
if ntx__.is_some() {
return Err(serde::de::Error::duplicate_field("ntx"));
}
ntx__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(BlockHeader {
version: version__.unwrap_or_default(),
hash: hash__.unwrap_or_default(),
height: height__.unwrap_or_default(),
previous_block_hash: previous_block_hash__.unwrap_or_default(),
merkle_root: merkle_root__.unwrap_or_default(),
nonce: nonce__.unwrap_or_default(),
bits: bits__.unwrap_or_default(),
time: time__.unwrap_or_default(),
ntx: ntx__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.oracle.BlockHeader", FIELDS, GeneratedVisitor)
}
}
#[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;
}
if !self.prices.is_empty() {
len += 1;
}
if !self.blocks.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.oracle.GenesisState", len)?;
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
if !self.prices.is_empty() {
struct_ser.serialize_field("prices", &self.prices)?;
}
if !self.blocks.is_empty() {
struct_ser.serialize_field("blocks", &self.blocks)?;
}
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", "prices", "blocks"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
Prices,
Blocks,
}
#[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),
"prices" => Ok(GeneratedField::Prices),
"blocks" => Ok(GeneratedField::Blocks),
_ => 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.oracle.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;
let mut prices__ = None;
let mut blocks__ = 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::Prices => {
if prices__.is_some() {
return Err(serde::de::Error::duplicate_field("prices"));
}
prices__ = Some(map_.next_value()?);
}
GeneratedField::Blocks => {
if blocks__.is_some() {
return Err(serde::de::Error::duplicate_field("blocks"));
}
blocks__ = Some(map_.next_value()?);
}
}
}
Ok(GenesisState {
params: params__,
prices: prices__.unwrap_or_default(),
blocks: blocks__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.oracle.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.oracle.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.oracle.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.oracle.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.oracle.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.oracle.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.oracle.MsgUpdateParamsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for OraclePrice {
#[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.symbol.is_empty() {
len += 1;
}
if !self.price.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.oracle.OraclePrice", len)?;
if !self.symbol.is_empty() {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if !self.price.is_empty() {
struct_ser.serialize_field("price", &self.price)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for OraclePrice {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["symbol", "price"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Price,
}
#[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 {
"symbol" => Ok(GeneratedField::Symbol),
"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 = OraclePrice;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.OraclePrice")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<OraclePrice, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut price__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Price => {
if price__.is_some() {
return Err(serde::de::Error::duplicate_field("price"));
}
price__ = Some(map_.next_value()?);
}
}
}
Ok(OraclePrice {
symbol: symbol__.unwrap_or_default(),
price: price__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.oracle.OraclePrice", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for OracleVoteExtension {
#[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.height != 0 {
len += 1;
}
if !self.prices.is_empty() {
len += 1;
}
if !self.blocks.is_empty() {
len += 1;
}
if self.has_error {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.oracle.OracleVoteExtension", len)?;
if self.height != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"height",
alloc::string::ToString::to_string(&self.height).as_str(),
)?;
}
if !self.prices.is_empty() {
struct_ser.serialize_field("prices", &self.prices)?;
}
if !self.blocks.is_empty() {
struct_ser.serialize_field("blocks", &self.blocks)?;
}
if self.has_error {
struct_ser.serialize_field("hasError", &self.has_error)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for OracleVoteExtension {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["height", "prices", "blocks", "has_error", "hasError"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Height,
Prices,
Blocks,
HasError,
}
#[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 {
"height" => Ok(GeneratedField::Height),
"prices" => Ok(GeneratedField::Prices),
"blocks" => Ok(GeneratedField::Blocks),
"hasError" | "has_error" => Ok(GeneratedField::HasError),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = OracleVoteExtension;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.OracleVoteExtension")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<OracleVoteExtension, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut height__ = None;
let mut prices__ = None;
let mut blocks__ = None;
let mut has_error__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Height => {
if height__.is_some() {
return Err(serde::de::Error::duplicate_field("height"));
}
height__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Prices => {
if prices__.is_some() {
return Err(serde::de::Error::duplicate_field("prices"));
}
prices__ = Some(map_.next_value::<std::collections::HashMap<_, _>>()?);
}
GeneratedField::Blocks => {
if blocks__.is_some() {
return Err(serde::de::Error::duplicate_field("blocks"));
}
blocks__ = Some(map_.next_value()?);
}
GeneratedField::HasError => {
if has_error__.is_some() {
return Err(serde::de::Error::duplicate_field("hasError"));
}
has_error__ = Some(map_.next_value()?);
}
}
}
Ok(OracleVoteExtension {
height: height__.unwrap_or_default(),
prices: prices__.unwrap_or_default(),
blocks: blocks__.unwrap_or_default(),
has_error: has_error__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.oracle.OracleVoteExtension", 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.keep_bitcoin_blocks != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.oracle.Params", len)?;
if self.keep_bitcoin_blocks != 0 {
struct_ser.serialize_field("keepBitcoinBlocks", &self.keep_bitcoin_blocks)?;
}
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] = &["keep_bitcoin_blocks", "keepBitcoinBlocks"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
KeepBitcoinBlocks,
}
#[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 {
"keepBitcoinBlocks" | "keep_bitcoin_blocks" => {
Ok(GeneratedField::KeepBitcoinBlocks)
}
_ => 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.oracle.Params")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut keep_bitcoin_blocks__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::KeepBitcoinBlocks => {
if keep_bitcoin_blocks__.is_some() {
return Err(serde::de::Error::duplicate_field("keepBitcoinBlocks"));
}
keep_bitcoin_blocks__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(Params {
keep_bitcoin_blocks: keep_bitcoin_blocks__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.oracle.Params", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBestBlockHeaderRequest {
#[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.oracle.QueryBestBlockHeaderRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBestBlockHeaderRequest {
#[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 = QueryBestBlockHeaderRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBestBlockHeaderRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBestBlockHeaderRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryBestBlockHeaderRequest {})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBestBlockHeaderRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBestBlockHeaderResponse {
#[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.block_header.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryBestBlockHeaderResponse", len)?;
if let Some(v) = self.block_header.as_ref() {
struct_ser.serialize_field("blockHeader", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBestBlockHeaderResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["block_header", "blockHeader"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BlockHeader,
}
#[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 {
"blockHeader" | "block_header" => Ok(GeneratedField::BlockHeader),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBestBlockHeaderResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBestBlockHeaderResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBestBlockHeaderResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut block_header__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BlockHeader => {
if block_header__.is_some() {
return Err(serde::de::Error::duplicate_field("blockHeader"));
}
block_header__ = map_.next_value()?;
}
}
}
Ok(QueryBestBlockHeaderResponse {
block_header: block_header__,
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBestBlockHeaderResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBlockHeaderByHashRequest {
#[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.hash.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryBlockHeaderByHashRequest", len)?;
if !self.hash.is_empty() {
struct_ser.serialize_field("hash", &self.hash)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBlockHeaderByHashRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["hash"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Hash,
}
#[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 {
"hash" => Ok(GeneratedField::Hash),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBlockHeaderByHashRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBlockHeaderByHashRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBlockHeaderByHashRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut hash__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Hash => {
if hash__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
hash__ = Some(map_.next_value()?);
}
}
}
Ok(QueryBlockHeaderByHashRequest {
hash: hash__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBlockHeaderByHashRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBlockHeaderByHashResponse {
#[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.block_header.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryBlockHeaderByHashResponse", len)?;
if let Some(v) = self.block_header.as_ref() {
struct_ser.serialize_field("blockHeader", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBlockHeaderByHashResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["block_header", "blockHeader"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BlockHeader,
}
#[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 {
"blockHeader" | "block_header" => Ok(GeneratedField::BlockHeader),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBlockHeaderByHashResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBlockHeaderByHashResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBlockHeaderByHashResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut block_header__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BlockHeader => {
if block_header__.is_some() {
return Err(serde::de::Error::duplicate_field("blockHeader"));
}
block_header__ = map_.next_value()?;
}
}
}
Ok(QueryBlockHeaderByHashResponse {
block_header: block_header__,
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBlockHeaderByHashResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBlockHeaderByHeightRequest {
#[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.height != 0 {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryBlockHeaderByHeightRequest", len)?;
if self.height != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"height",
alloc::string::ToString::to_string(&self.height).as_str(),
)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBlockHeaderByHeightRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["height"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Height,
}
#[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 {
"height" => Ok(GeneratedField::Height),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBlockHeaderByHeightRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBlockHeaderByHeightRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBlockHeaderByHeightRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut height__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Height => {
if height__.is_some() {
return Err(serde::de::Error::duplicate_field("height"));
}
height__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(QueryBlockHeaderByHeightRequest {
height: height__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBlockHeaderByHeightRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBlockHeaderByHeightResponse {
#[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.block_header.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryBlockHeaderByHeightResponse", len)?;
if let Some(v) = self.block_header.as_ref() {
struct_ser.serialize_field("blockHeader", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBlockHeaderByHeightResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["block_header", "blockHeader"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BlockHeader,
}
#[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 {
"blockHeader" | "block_header" => Ok(GeneratedField::BlockHeader),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBlockHeaderByHeightResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryBlockHeaderByHeightResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryBlockHeaderByHeightResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut block_header__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BlockHeader => {
if block_header__.is_some() {
return Err(serde::de::Error::duplicate_field("blockHeader"));
}
block_header__ = map_.next_value()?;
}
}
}
Ok(QueryBlockHeaderByHeightResponse {
block_header: block_header__,
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryBlockHeaderByHeightResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryChainTipRequest {
#[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.oracle.QueryChainTipRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryChainTipRequest {
#[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 = QueryChainTipRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryChainTipRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryChainTipRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryChainTipRequest {})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryChainTipRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryChainTipResponse {
#[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.hash.is_empty() {
len += 1;
}
if self.height != 0 {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryChainTipResponse", len)?;
if !self.hash.is_empty() {
struct_ser.serialize_field("hash", &self.hash)?;
}
if self.height != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"height",
alloc::string::ToString::to_string(&self.height).as_str(),
)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryChainTipResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["hash", "height"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Hash,
Height,
}
#[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 {
"hash" => Ok(GeneratedField::Hash),
"height" => Ok(GeneratedField::Height),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryChainTipResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryChainTipResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryChainTipResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut hash__ = None;
let mut height__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Hash => {
if hash__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
hash__ = 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,
);
}
}
}
Ok(QueryChainTipResponse {
hash: hash__.unwrap_or_default(),
height: height__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryChainTipResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryGetPriceBySymbolRequest {
#[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.symbol.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryGetPriceBySymbolRequest", len)?;
if !self.symbol.is_empty() {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryGetPriceBySymbolRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["symbol"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
}
#[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 {
"symbol" => Ok(GeneratedField::Symbol),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryGetPriceBySymbolRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryGetPriceBySymbolRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryGetPriceBySymbolRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
}
}
Ok(QueryGetPriceBySymbolRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryGetPriceBySymbolRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryGetPriceBySymbolResponse {
#[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.price.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryGetPriceBySymbolResponse", len)?;
if !self.price.is_empty() {
struct_ser.serialize_field("price", &self.price)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryGetPriceBySymbolResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["price"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Price,
}
#[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 {
"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 = QueryGetPriceBySymbolResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryGetPriceBySymbolResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryGetPriceBySymbolResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut price__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Price => {
if price__.is_some() {
return Err(serde::de::Error::duplicate_field("price"));
}
price__ = Some(map_.next_value()?);
}
}
}
Ok(QueryGetPriceBySymbolResponse {
price: price__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryGetPriceBySymbolResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryListPricesRequest {
#[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.oracle.QueryListPricesRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryListPricesRequest {
#[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 = QueryListPricesRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryListPricesRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryListPricesRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryListPricesRequest {})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryListPricesRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryListPricesResponse {
#[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.prices.is_empty() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.oracle.QueryListPricesResponse", len)?;
if !self.prices.is_empty() {
struct_ser.serialize_field("prices", &self.prices)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryListPricesResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["prices"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Prices,
}
#[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 {
"prices" => Ok(GeneratedField::Prices),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryListPricesResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.oracle.QueryListPricesResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryListPricesResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut prices__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Prices => {
if prices__.is_some() {
return Err(serde::de::Error::duplicate_field("prices"));
}
prices__ = Some(map_.next_value()?);
}
}
}
Ok(QueryListPricesResponse {
prices: prices__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.oracle.QueryListPricesResponse",
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.oracle.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.oracle.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.oracle.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.oracle.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.oracle.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.oracle.QueryParamsResponse", FIELDS, GeneratedVisitor)
}
}