use super::{BlockContext, BlockSelector, Finality, Inclusion, NetworkId, Source, Timestamp};
use crate::error::{Error, ValidationError};
use serde::{Deserialize, Deserializer, Serialize};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ReadOperation {
Erc20Balance,
Erc20Allowance,
Erc20Metadata,
Transaction,
Receipt,
TransactionStatus,
AccountNonce,
Call,
GasEstimate,
FeeSuggestions,
SignedSubmission,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum ReadState {
CanonicalHash {
requested_selector: BlockSelector,
block: BlockContext,
},
Included {
inclusion: Inclusion,
},
Pending,
Unanchored,
}
impl ReadState {
fn validate(self) -> Result<(), Error> {
if let Self::CanonicalHash {
requested_selector,
block,
} = self
{
let mismatch = match requested_selector {
BlockSelector::Number(n) => n != block.number(),
BlockSelector::Hash(h) => h != *block.hash(),
BlockSelector::Latest | BlockSelector::Safe | BlockSelector::Finalized => false,
};
if mismatch {
return Err(ValidationError::BlockMismatch.into());
}
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ContextFields")]
pub struct OperationContext {
schema_version: u16,
operation: ReadOperation,
network: NetworkId,
state: ReadState,
source: Source,
retrieved_at: Timestamp,
finality: Finality,
confirmations: Option<u64>,
}
impl OperationContext {
pub fn new(
operation: ReadOperation,
network: NetworkId,
state: ReadState,
source: Source,
retrieved_at: Timestamp,
) -> Result<Self, Error> {
state.validate()?;
Ok(Self {
schema_version: 1,
operation,
network,
state,
source,
retrieved_at,
finality: Finality::Unknown,
confirmations: None,
})
}
#[must_use]
pub const fn schema_version(&self) -> u16 {
self.schema_version
}
#[must_use]
pub const fn operation(&self) -> ReadOperation {
self.operation
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub const fn state(&self) -> ReadState {
self.state
}
#[must_use]
pub const fn source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn retrieved_at(&self) -> Timestamp {
self.retrieved_at
}
#[must_use]
pub const fn finality(&self) -> Finality {
self.finality
}
#[must_use]
pub const fn confirmations(&self) -> Option<u64> {
self.confirmations
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ContextFields {
schema_version: u16,
operation: ReadOperation,
network: NetworkId,
state: ReadState,
source: Source,
retrieved_at: Timestamp,
finality: Finality,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
confirmations: Option<u64>,
}
impl TryFrom<ContextFields> for OperationContext {
type Error = Error;
fn try_from(v: ContextFields) -> Result<Self, Error> {
if v.schema_version != 1 {
return Err(ValidationError::UnsupportedSchemaVersion.into());
}
if v.finality != Finality::Unknown || v.confirmations.is_some() {
return Err(ValidationError::InvalidEvmRecord.into());
}
Self::new(v.operation, v.network, v.state, v.source, v.retrieved_at)
}
}
pub trait OperationValue {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error>;
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct OperationObservation<T: OperationValue> {
value: T,
context: OperationContext,
}
impl<T: OperationValue> OperationObservation<T> {
pub fn new(value: T, context: OperationContext) -> 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) -> &OperationContext {
&self.context
}
}
impl<'de, T: OperationValue + Deserialize<'de>> Deserialize<'de> for OperationObservation<T> {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Fields<T> {
value: T,
context: OperationContext,
}
let v = Fields::<T>::deserialize(d)?;
Self::new(v.value, v.context).map_err(serde::de::Error::custom)
}
}