use super::{CallSettings, V3QuoteObservation, encoding, quote::canonical_block};
use crate::{
domain::evm::{Address, ChainId, Quantity, Timestamp, TransactionCall, U256},
error::{Error, ValidationError},
wallets::Preparation,
};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "u16", into = "u16")]
pub struct SlippageBps(u16);
impl SlippageBps {
pub fn new(value: u16) -> Result<Self, Error> {
if value > 10_000 {
return Err(invalid());
}
Ok(Self(value))
}
#[must_use]
pub const fn value(self) -> u16 {
self.0
}
#[must_use]
pub fn minimum_output(self, output: Quantity) -> Quantity {
let scale = U256::from(10_000);
let retained = U256::from(10_000 - self.0);
Quantity::new(
(output.value() / scale) * retained + (output.value() % scale) * retained / scale,
)
}
}
impl TryFrom<u16> for SlippageBps {
type Error = Error;
fn try_from(value: u16) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<SlippageBps> for u16 {
fn from(value: SlippageBps) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SwapIntentData {
pub quote: V3QuoteObservation,
pub recipient: Address,
pub slippage: SlippageBps,
pub deadline: Timestamp,
pub settings: CallSettings,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SwapIntentData", into = "SwapIntentData")]
pub struct SwapIntent(SwapIntentData);
impl SwapIntent {
pub fn new(data: SwapIntentData) -> Result<Self, Error> {
let recipient = U256::from_be_slice(&data.recipient.bytes());
if recipient <= U256::from(2)
|| data
.quote
.value()
.data()
.request
.data()
.amount_in
.value()
.bit_len()
> 160
|| data.deadline < canonical_block(data.quote.context())?.timestamp()
{
return Err(invalid());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &SwapIntentData {
&self.0
}
#[must_use]
pub fn minimum_output(&self) -> Quantity {
self.0
.slippage
.minimum_output(self.0.quote.value().data().amount_out)
}
}
impl fmt::Debug for SwapIntent {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SwapIntent").finish_non_exhaustive()
}
}
impl TryFrom<SwapIntentData> for SwapIntent {
type Error = Error;
fn try_from(value: SwapIntentData) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<SwapIntent> for SwapIntentData {
fn from(value: SwapIntent) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct AllowanceRequirements {
pub token: Address,
pub owner: Address,
pub erc20_spender: Address,
pub permit2_spender: Address,
pub amount: Quantity,
}
#[derive(Clone, Eq, PartialEq, Serialize)]
pub struct UnsignedSwap {
call: TransactionCall,
allowances: AllowanceRequirements,
}
impl UnsignedSwap {
#[must_use]
pub const fn call(&self) -> &TransactionCall {
&self.call
}
#[must_use]
pub const fn allowances(&self) -> &AllowanceRequirements {
&self.allowances
}
}
impl fmt::Debug for UnsignedSwap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("UnsignedSwap").finish_non_exhaustive()
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct PreparedSwap {
intent: SwapIntent,
unsigned: UnsignedSwap,
}
impl PreparedSwap {
pub fn new(intent: SwapIntent) -> Result<Self, Error> {
let request = intent.data().quote.value().data().request.data();
let deployment = request.deployment.data();
let call = intent.data().settings.call(
deployment.chain_id,
deployment.universal_router_2_1_2,
encoding::swap_call(&intent)?,
)?;
let allowances = AllowanceRequirements {
token: request.path.token_in(),
owner: intent.data().settings.data().from,
erc20_spender: deployment.permit2,
permit2_spender: deployment.universal_router_2_1_2,
amount: request.amount_in,
};
Ok(Self {
intent,
unsigned: UnsignedSwap { call, allowances },
})
}
#[must_use]
pub const fn intent(&self) -> &SwapIntent {
&self.intent
}
#[must_use]
pub const fn unsigned(&self) -> &UnsignedSwap {
&self.unsigned
}
}
impl Preparation for PreparedSwap {
type Network = ChainId;
type Intent = SwapIntent;
type UnsignedPayload = UnsignedSwap;
fn network(&self) -> &ChainId {
self.intent
.data()
.quote
.value()
.data()
.request
.data()
.deployment
.chain_id_ref()
}
fn intent(&self) -> &SwapIntent {
&self.intent
}
fn unsigned_payload(&self) -> &UnsignedSwap {
&self.unsigned
}
fn validate(&self) -> Result<(), Error> {
if *self != Self::new(self.intent.clone())? {
return Err(invalid());
}
Ok(())
}
}
impl fmt::Debug for PreparedSwap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PreparedSwap").finish_non_exhaustive()
}
}
impl Serialize for PreparedSwap {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.intent.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for PreparedSwap {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Self::new(SwapIntent::deserialize(deserializer)?).map_err(serde::de::Error::custom)
}
}
fn invalid() -> Error {
ValidationError::InvalidUniswapPreparation.into()
}