use crate::{
domain::evm::{Address, Data},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct V3PathData {
pub tokens: Vec<Address>,
pub fees: Vec<u32>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "V3PathData", into = "V3PathData")]
pub struct V3Path(V3PathData);
impl V3Path {
pub const MAX_HOPS: usize = 8;
pub fn new(data: V3PathData) -> Result<Self, Error> {
if data.fees.is_empty()
|| data.fees.len() > Self::MAX_HOPS
|| data.tokens.len() != data.fees.len() + 1
|| data
.tokens
.iter()
.any(|a| *a == Address::from_bytes([0; 20]))
|| data.tokens.windows(2).any(|p| p[0] == p[1])
|| data.fees.iter().any(|f| *f >= 1_000_000)
{
return Err(ValidationError::InvalidUniswapPath.into());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &V3PathData {
&self.0
}
#[must_use]
pub fn hops(&self) -> usize {
self.0.fees.len()
}
#[must_use]
pub fn token_in(&self) -> Address {
self.0.tokens[0]
}
#[must_use]
pub fn token_out(&self) -> Address {
self.0.tokens[self.0.fees.len()]
}
pub fn encoded(&self) -> Result<Data, Error> {
let mut bytes = Vec::with_capacity(20 + 23 * self.hops());
bytes.extend(self.token_in().bytes());
for (index, fee) in self.0.fees.iter().enumerate() {
bytes.extend(&fee.to_be_bytes()[1..]);
bytes.extend(self.0.tokens[index + 1].bytes());
}
Data::new(bytes)
}
}
impl TryFrom<V3PathData> for V3Path {
type Error = Error;
fn try_from(data: V3PathData) -> Result<Self, Error> {
Self::new(data)
}
}
impl From<V3Path> for V3PathData {
fn from(value: V3Path) -> Self {
value.0
}
}