use serde::{Deserialize, Deserializer, Serialize};
use crate::{
domain::{Source, Timestamp},
error::{Error, ValidationError},
};
use super::{AccountLookup, Hash, NativeBalance, Network, TokenBalance};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Commitment {
Processed,
Confirmed,
Finalized,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReadOptions {
commitment: Commitment,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
minimum_context_slot: Option<u64>,
}
impl ReadOptions {
#[must_use]
pub const fn new(commitment: Commitment, minimum_context_slot: Option<u64>) -> Self {
Self {
commitment,
minimum_context_slot,
}
}
#[must_use]
pub const fn commitment(self) -> Commitment {
self.commitment
}
#[must_use]
pub const fn minimum_context_slot(self) -> Option<u64> {
self.minimum_context_slot
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Operation {
NativeBalance,
TokenBalance,
Account,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ContextFields")]
pub struct Context {
schema_version: u16,
operation: Operation,
network: Network,
requested_options: ReadOptions,
slot: u64,
source: Source,
retrieved_at: Timestamp,
}
impl Context {
pub fn new(
operation: Operation,
network: Network,
requested_options: ReadOptions,
slot: u64,
source: Source,
retrieved_at: Timestamp,
) -> Result<Self, Error> {
if requested_options
.minimum_context_slot()
.is_some_and(|minimum| slot < minimum)
{
return Err(ValidationError::ContextSlotBelowMinimum.into());
}
Ok(Self {
schema_version: 1,
operation,
network,
requested_options,
slot,
source,
retrieved_at,
})
}
#[must_use]
pub const fn schema_version(&self) -> u16 {
self.schema_version
}
#[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 requested_options(&self) -> ReadOptions {
self.requested_options
}
#[must_use]
pub const fn slot(&self) -> u64 {
self.slot
}
#[must_use]
pub const fn source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn retrieved_at(&self) -> Timestamp {
self.retrieved_at
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ContextFields {
schema_version: u16,
operation: Operation,
network: Network,
requested_options: ReadOptions,
slot: u64,
source: Source,
retrieved_at: Timestamp,
}
impl TryFrom<ContextFields> for Context {
type Error = Error;
fn try_from(fields: ContextFields) -> Result<Self, Self::Error> {
if fields.schema_version != 1 {
return Err(ValidationError::UnsupportedSchemaVersion.into());
}
Self::new(
fields.operation,
fields.network,
fields.requested_options,
fields.slot,
fields.source,
fields.retrieved_at,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Observation<T> {
#[serde(flatten)]
context: Context,
value: T,
}
impl<T> Observation<T> {
#[must_use]
pub const fn value(&self) -> &T {
&self.value
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
fn validated(
value: T,
context: Context,
operation: Operation,
genesis_hash: Hash,
) -> Result<Self, Error> {
if context.operation() != operation {
return Err(ValidationError::ObservationOperationMismatch.into());
}
if context.network().genesis_hash() != genesis_hash {
return Err(ValidationError::NetworkMismatch.into());
}
Ok(Self { context, value })
}
}
impl Observation<NativeBalance> {
pub fn native_balance(value: NativeBalance, context: Context) -> Result<Self, Error> {
let genesis_hash = value.network().genesis_hash();
Self::validated(value, context, Operation::NativeBalance, genesis_hash)
}
}
impl Observation<TokenBalance> {
pub fn token_balance(value: TokenBalance, context: Context) -> Result<Self, Error> {
let genesis_hash = value.asset().network().genesis_hash();
Self::validated(value, context, Operation::TokenBalance, genesis_hash)
}
}
impl Observation<AccountLookup> {
pub fn account(value: AccountLookup, context: Context) -> Result<Self, Error> {
let genesis_hash = value.network().genesis_hash();
Self::validated(value, context, Operation::Account, genesis_hash)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ObservationFields<T> {
schema_version: u16,
operation: Operation,
network: Network,
requested_options: ReadOptions,
slot: u64,
source: Source,
retrieved_at: Timestamp,
value: T,
}
impl<T> ObservationFields<T> {
fn into_parts(self) -> Result<(T, Context), Error> {
let context = Context::try_from(ContextFields {
schema_version: self.schema_version,
operation: self.operation,
network: self.network,
requested_options: self.requested_options,
slot: self.slot,
source: self.source,
retrieved_at: self.retrieved_at,
})?;
Ok((self.value, context))
}
}
macro_rules! observation_deserialize {
($value:ty, $constructor:ident) => {
impl<'de> Deserialize<'de> for Observation<$value> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let (value, context) = ObservationFields::<$value>::deserialize(deserializer)?
.into_parts()
.map_err(serde::de::Error::custom)?;
Self::$constructor(value, context).map_err(serde::de::Error::custom)
}
}
};
}
observation_deserialize!(NativeBalance, native_balance);
observation_deserialize!(TokenBalance, token_balance);
observation_deserialize!(AccountLookup, account);