use super::{V3QuoteRequest, V3RouteRequest};
use crate::{
domain::evm::{
AccountNonce, BlockContext, OperationContext, OperationObservation, OperationValue,
Quantity, ReadOperation, ReadState,
},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct V3QuoteData {
pub request: V3QuoteRequest,
pub amount_out: Quantity,
pub sqrt_price_x96_after: Vec<Quantity>,
pub initialized_ticks_crossed: Vec<u32>,
pub gas_estimate: Quantity,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "V3QuoteData", into = "V3QuoteData")]
pub struct V3Quote(V3QuoteData);
impl V3Quote {
pub fn new(data: V3QuoteData) -> Result<Self, Error> {
let hops = data.request.data().path.hops();
if data.sqrt_price_x96_after.len() != hops
|| data.initialized_ticks_crossed.len() != hops
|| data
.sqrt_price_x96_after
.iter()
.any(|p| p.value().bit_len() > 160)
{
return Err(invalid());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &V3QuoteData {
&self.0
}
}
impl TryFrom<V3QuoteData> for V3Quote {
type Error = Error;
fn try_from(data: V3QuoteData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<V3Quote> for V3QuoteData {
fn from(value: V3Quote) -> Self {
value.0
}
}
impl OperationValue for V3Quote {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error> {
if context.operation() != ReadOperation::Call
|| context.network().chain_id() != self.0.request.data().deployment.chain_id()
|| !matches!(context.state(), ReadState::CanonicalHash { .. })
{
return Err(invalid());
}
Ok(())
}
}
pub type V3QuoteObservation = OperationObservation<V3Quote>;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum RouteOutcome {
Quoted {
quote: Box<V3QuoteObservation>,
},
Reverted {
request: Box<V3QuoteRequest>,
},
}
impl RouteOutcome {
#[must_use]
pub fn request(&self) -> &V3QuoteRequest {
match self {
Self::Quoted { quote } => "e.value().data().request,
Self::Reverted { request } => request,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RouteComparisonData {
pub request: V3RouteRequest,
pub anchor: OperationObservation<AccountNonce>,
pub outcomes: Vec<RouteOutcome>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RouteComparisonData", into = "RouteComparisonData")]
pub struct RouteComparison {
data: RouteComparisonData,
best_index: Option<usize>,
}
impl RouteComparison {
pub fn new(data: RouteComparisonData) -> Result<Self, Error> {
let anchor = data.anchor.context();
let block = canonical_block(anchor)?;
if data.anchor.value().address != data.request.data().settings.data().from
|| anchor.network().chain_id() != data.request.data().deployment.chain_id()
|| data.outcomes.len() != data.request.data().paths.len()
{
return Err(invalid());
}
let mut best_index = None;
let mut best_amount = None;
for (index, outcome) in data.outcomes.iter().enumerate() {
if *outcome.request() != data.request.candidate(index)? {
return Err(invalid());
}
if let RouteOutcome::Quoted { quote } = outcome {
let context = quote.context();
if canonical_block(context)? != block
|| context.network() != anchor.network()
|| context.source().provider_id() != anchor.source().provider_id()
|| context.source().integration_version()
!= anchor.source().integration_version()
{
return Err(invalid());
}
let amount = quote.value().data().amount_out;
if best_amount.is_none_or(|best| amount > best) {
best_index = Some(index);
best_amount = Some(amount);
}
}
}
Ok(Self { data, best_index })
}
#[must_use]
pub const fn data(&self) -> &RouteComparisonData {
&self.data
}
#[must_use]
pub const fn best_index(&self) -> Option<usize> {
self.best_index
}
#[must_use]
pub fn best_quote(&self) -> Option<&V3QuoteObservation> {
self.best_index
.and_then(|index| match &self.data.outcomes[index] {
RouteOutcome::Quoted { quote } => Some(quote.as_ref()),
RouteOutcome::Reverted { .. } => None,
})
}
}
impl TryFrom<RouteComparisonData> for RouteComparison {
type Error = Error;
fn try_from(data: RouteComparisonData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<RouteComparison> for RouteComparisonData {
fn from(value: RouteComparison) -> Self {
value.data
}
}
pub(super) fn canonical_block(context: &OperationContext) -> Result<BlockContext, Error> {
match context.state() {
ReadState::CanonicalHash { block, .. } => Ok(block),
_ => Err(invalid()),
}
}
fn invalid() -> Error {
ValidationError::InvalidUniswapQuote.into()
}