use serde::{Deserialize, Deserializer, Serialize};
use crate::{
domain::{Source, Timestamp},
error::{Error, ValidationError},
};
use super::{
AddressBalance, AddressDetails, AssetDetails, Epoch, IndexPage, Network, NetworkData,
NetworkId, PageItem, PageTarget, PaymentEstimate, ProtocolParameters, StakeAccount,
SubmissionResult, Transaction, TransactionStatus, TransactionUtxos, UtxoPage,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Operation {
Balance,
Utxos,
AddressDetails,
AddressTransactions,
NetworkData,
Epoch,
ProtocolParameters,
StakeAccount,
Rewards,
Assets,
AssetDetails,
AssetTransactions,
AssetHolders,
Transaction,
TransactionUtxos,
TransactionStatus,
PaymentEstimate,
Submission,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Context {
operation: Operation,
network: Network,
source: Source,
retrieved_at: Timestamp,
}
impl Context {
#[must_use]
pub const fn new(
operation: Operation,
network: Network,
source: Source,
retrieved_at: Timestamp,
) -> Self {
Self {
operation,
network,
source,
retrieved_at,
}
}
#[must_use]
pub const fn operation(&self) -> Operation {
self.operation
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[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 validated(
value: T,
context: Context,
operation: Operation,
network: NetworkId,
) -> Result<Self, Error> {
if context.operation() != operation {
return Err(ValidationError::ObservationOperationMismatch.into());
}
if context.network().identity() != network {
return Err(ValidationError::NetworkMismatch.into());
}
Ok(Self {
schema_version: 1,
context,
value,
})
}
}
impl Observation<AddressBalance> {
pub fn balance(value: AddressBalance, context: Context) -> Result<Self, Error> {
let network = value.network().identity();
Self::validated(value, context, Operation::Balance, network)
}
}
impl Observation<UtxoPage> {
pub fn utxos(value: UtxoPage, context: Context) -> Result<Self, Error> {
let network = value.network().identity();
Self::validated(value, context, Operation::Utxos, network)
}
}
pub trait ObservationValue {
fn operation(&self) -> Operation;
fn network_identity(&self) -> NetworkId;
}
macro_rules! observed {
($type:ty,$operation:ident) => {
impl ObservationValue for $type {
fn operation(&self) -> Operation {
Operation::$operation
}
fn network_identity(&self) -> NetworkId {
self.network().identity()
}
}
};
}
observed!(AddressBalance, Balance);
observed!(UtxoPage, Utxos);
observed!(AddressDetails, AddressDetails);
observed!(NetworkData, NetworkData);
observed!(Epoch, Epoch);
observed!(ProtocolParameters, ProtocolParameters);
observed!(StakeAccount, StakeAccount);
observed!(AssetDetails, AssetDetails);
observed!(Transaction, Transaction);
observed!(TransactionUtxos, TransactionUtxos);
observed!(TransactionStatus, TransactionStatus);
observed!(PaymentEstimate, PaymentEstimate);
observed!(SubmissionResult, Submission);
impl<T: PageItem> ObservationValue for IndexPage<T> {
fn operation(&self) -> Operation {
match self.target() {
PageTarget::Assets => Operation::Assets,
PageTarget::AddressTransactions { .. } => Operation::AddressTransactions,
PageTarget::AssetTransactions { .. } => Operation::AssetTransactions,
PageTarget::AssetHolders { .. } => Operation::AssetHolders,
PageTarget::Rewards { .. } => Operation::Rewards,
}
}
fn network_identity(&self) -> NetworkId {
self.network().identity()
}
}
impl<T: ObservationValue> Observation<T> {
pub fn new(value: T, context: Context) -> Result<Self, Error> {
let operation = value.operation();
let network = value.network_identity();
Self::validated(value, context, operation, network)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Fields<T> {
schema_version: u16,
context: Context,
value: T,
}
impl<'de, T: ObservationValue + Deserialize<'de>> Deserialize<'de> for Observation<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let v = Fields::<T>::deserialize(d)?;
if v.schema_version != 1 {
return Err(serde::de::Error::custom(
ValidationError::UnsupportedSchemaVersion,
));
}
Self::new(v.value, v.context).map_err(serde::de::Error::custom)
}
}