use serde::{Deserialize, Deserializer, Serialize};
use crate::{
domain::{Source, Timestamp, bitcoin::NetworkId},
error::{Error, ValidationError},
};
use super::{
MempoolSummary, RecentTransactions, RecommendedFees, TransactionIds, TransactionLimit,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum Operation {
Summary,
RecentTransactions,
TransactionIds {
limit: TransactionLimit,
},
RecommendedFees,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Context {
network: NetworkId,
operation: Operation,
source: Source,
retrieved_at: Timestamp,
}
impl Context {
#[must_use]
pub const fn new(
network: NetworkId,
operation: Operation,
source: Source,
retrieved_at: Timestamp,
) -> Self {
Self {
network,
operation,
source,
retrieved_at,
}
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub const fn operation(&self) -> Operation {
self.operation
}
#[must_use]
pub const fn source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn retrieved_at(&self) -> Timestamp {
self.retrieved_at
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Observation<T> {
schema_version: u16,
context: Context,
value: T,
}
impl<T> Observation<T> {
#[must_use]
pub const fn schema_version(&self) -> u16 {
self.schema_version
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
#[must_use]
pub const fn value(&self) -> &T {
&self.value
}
fn new(value: T, context: Context, operation: Operation) -> Result<Self, Error> {
if context.operation() != operation {
return Err(ValidationError::ObservationOperationMismatch.into());
}
Ok(Self {
schema_version: 1,
context,
value,
})
}
}
impl Observation<MempoolSummary> {
pub fn summary(value: MempoolSummary, context: Context) -> Result<Self, Error> {
Self::new(value, context, Operation::Summary)
}
}
impl Observation<RecentTransactions> {
pub fn recent_transactions(value: RecentTransactions, context: Context) -> Result<Self, Error> {
Self::new(value, context, Operation::RecentTransactions)
}
}
impl Observation<TransactionIds> {
pub fn transaction_ids(value: TransactionIds, context: Context) -> Result<Self, Error> {
let operation = Operation::TransactionIds {
limit: value.limit(),
};
Self::new(value, context, operation)
}
}
impl Observation<RecommendedFees> {
pub fn recommended_fees(value: RecommendedFees, context: Context) -> Result<Self, Error> {
Self::new(value, context, Operation::RecommendedFees)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Fields<T> {
schema_version: u16,
context: Context,
value: T,
}
macro_rules! observation_serde {
($type:ty, $constructor:ident) => {
impl<'de> Deserialize<'de> for Observation<$type> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let fields = Fields::<$type>::deserialize(d)?;
if fields.schema_version != 1 {
return Err(serde::de::Error::custom(
ValidationError::UnsupportedSchemaVersion,
));
}
Self::$constructor(fields.value, fields.context).map_err(serde::de::Error::custom)
}
}
};
}
observation_serde!(MempoolSummary, summary);
observation_serde!(RecentTransactions, recent_transactions);
observation_serde!(TransactionIds, transaction_ids);
observation_serde!(RecommendedFees, recommended_fees);