use crate::{
domain::{Source, Timestamp, solana::Network},
error::{Error, ValidationError},
};
use serde::{Deserialize, Deserializer, Serialize};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Operation {
OrderQuote,
Build,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "Fields")]
pub struct Context {
schema_version: u16,
operation: Operation,
network: Network,
source: Source,
retrieved_at: Timestamp,
}
impl Context {
pub fn new(
operation: Operation,
network: Network,
source: Source,
retrieved_at: Timestamp,
) -> Result<Self, Error> {
super::request::validate_network(&network)?;
Ok(Self {
schema_version: 1,
operation,
network,
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 source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn retrieved_at(&self) -> Timestamp {
self.retrieved_at
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Fields {
schema_version: u16,
operation: Operation,
network: Network,
source: Source,
retrieved_at: Timestamp,
}
impl TryFrom<Fields> for Context {
type Error = Error;
fn try_from(v: Fields) -> Result<Self, Error> {
if v.schema_version != 1 {
return Err(ValidationError::UnsupportedSchemaVersion.into());
}
Self::new(v.operation, v.network, v.source, v.retrieved_at)
}
}
pub trait OperationValue {
fn validate_context(&self, context: &Context) -> Result<(), Error>;
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct Observation<T: OperationValue> {
value: T,
context: Context,
}
impl<T: OperationValue> Observation<T> {
pub fn new(value: T, context: Context) -> Result<Self, Error> {
value.validate_context(&context)?;
Ok(Self { value, context })
}
#[must_use]
pub const fn value(&self) -> &T {
&self.value
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
}
impl<'de, T: OperationValue + Deserialize<'de>> Deserialize<'de> for Observation<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct F<T> {
value: T,
context: Context,
}
let v = F::<T>::deserialize(d)?;
Self::new(v.value, v.context).map_err(serde::de::Error::custom)
}
}