use super::{V3Deployment, V3Path, encoding};
use crate::{
domain::evm::{
Address, ChainId, Data, FeeTerms, Quantity, TransactionCall, TransactionCallData, U256,
},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CallSettingsData {
pub from: Address,
pub nonce: u64,
pub gas_limit: u64,
pub fees: FeeTerms,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "CallSettingsData", into = "CallSettingsData")]
pub struct CallSettings(CallSettingsData);
impl CallSettings {
pub fn new(data: CallSettingsData) -> Result<Self, Error> {
TransactionCall::new(TransactionCallData {
chain_id: ChainId::from(0),
from: data.from,
to: None,
nonce: data.nonce,
gas_limit: data.gas_limit,
value: Quantity::from(0),
input: Data::new(vec![])?,
fees: data.fees.clone(),
})
.map_err(|_| Error::from(ValidationError::InvalidUniswapPreparation))?;
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &CallSettingsData {
&self.0
}
pub(super) fn call(
&self,
chain_id: ChainId,
to: Address,
input: Data,
) -> Result<TransactionCall, Error> {
TransactionCall::new(TransactionCallData {
chain_id,
from: self.0.from,
to: Some(to),
nonce: self.0.nonce,
gas_limit: self.0.gas_limit,
value: Quantity::from(0),
input,
fees: self.0.fees.clone(),
})
}
}
impl fmt::Debug for CallSettings {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CallSettings").finish_non_exhaustive()
}
}
impl TryFrom<CallSettingsData> for CallSettings {
type Error = Error;
fn try_from(data: CallSettingsData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<CallSettings> for CallSettingsData {
fn from(value: CallSettings) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct V3QuoteRequestData {
pub deployment: V3Deployment,
pub path: V3Path,
pub amount_in: Quantity,
pub settings: CallSettings,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "V3QuoteRequestData", into = "V3QuoteRequestData")]
pub struct V3QuoteRequest(V3QuoteRequestData);
impl V3QuoteRequest {
pub fn new(data: V3QuoteRequestData) -> Result<Self, Error> {
if data.amount_in.value() == U256::ZERO
|| data.amount_in.value() > U256::MAX / U256::from(2)
{
return Err(ValidationError::InvalidUniswapQuote.into());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &V3QuoteRequestData {
&self.0
}
pub fn call(&self) -> Result<TransactionCall, Error> {
self.0.settings.call(
self.0.deployment.chain_id(),
self.0.deployment.data().quoter_v2,
encoding::quote_call(&self.0.path, self.0.amount_in)?,
)
}
}
impl TryFrom<V3QuoteRequestData> for V3QuoteRequest {
type Error = Error;
fn try_from(data: V3QuoteRequestData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<V3QuoteRequest> for V3QuoteRequestData {
fn from(value: V3QuoteRequest) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct V3RouteRequestData {
pub deployment: V3Deployment,
pub paths: Vec<V3Path>,
pub amount_in: Quantity,
pub settings: CallSettings,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "V3RouteRequestData", into = "V3RouteRequestData")]
pub struct V3RouteRequest(V3RouteRequestData);
impl V3RouteRequest {
pub const MAX_CANDIDATES: usize = 16;
pub fn new(data: V3RouteRequestData) -> Result<Self, Error> {
if data.paths.is_empty() || data.paths.len() > Self::MAX_CANDIDATES {
return Err(ValidationError::InvalidUniswapPath.into());
}
let first = &data.paths[0];
for (index, path) in data.paths.iter().enumerate() {
if path.token_in() != first.token_in()
|| path.token_out() != first.token_out()
|| data.paths[..index].contains(path)
{
return Err(ValidationError::InvalidUniswapPath.into());
}
V3QuoteRequest::new(V3QuoteRequestData {
deployment: data.deployment.clone(),
path: path.clone(),
amount_in: data.amount_in,
settings: data.settings.clone(),
})?;
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &V3RouteRequestData {
&self.0
}
pub fn candidate(&self, index: usize) -> Result<V3QuoteRequest, Error> {
V3QuoteRequest::new(V3QuoteRequestData {
deployment: self.0.deployment.clone(),
path: self
.0
.paths
.get(index)
.ok_or(ValidationError::InvalidUniswapPath)?
.clone(),
amount_in: self.0.amount_in,
settings: self.0.settings.clone(),
})
}
}
impl TryFrom<V3RouteRequestData> for V3RouteRequest {
type Error = Error;
fn try_from(data: V3RouteRequestData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<V3RouteRequest> for V3RouteRequestData {
fn from(value: V3RouteRequest) -> Self {
value.0
}
}