use super::{Account, Asset, Identifier};
use crate::{domain::Amount, error::Error};
use serde::{Deserialize, Serialize};
use std::collections::BTreeSet;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "u16", into = "u16")]
pub struct SlippageBps(u16);
impl SlippageBps {
pub fn new(v: u16) -> Result<Self, Error> {
if v > 5000 {
return Err(super::invalid_request());
}
Ok(Self(v))
}
#[must_use]
pub const fn get(self) -> u16 {
self.0
}
#[must_use]
pub fn fraction(self) -> String {
if self.0 == 0 {
return "0".into();
}
format!("0.{:04}", self.0).trim_end_matches('0').into()
}
}
impl TryFrom<u16> for SlippageBps {
type Error = Error;
fn try_from(v: u16) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<SlippageBps> for u16 {
fn from(v: SlippageBps) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "LimitFields")]
pub struct Limits {
chains: u16,
routes: u16,
legs: u16,
path_tokens: u16,
warnings: u16,
}
impl Limits {
pub fn new(
chains: u16,
routes: u16,
legs: u16,
path_tokens: u16,
warnings: u16,
) -> Result<Self, Error> {
if chains == 0
|| chains > 512
|| [routes, legs, path_tokens, warnings]
.iter()
.any(|v| *v == 0 || *v > 128)
{
return Err(super::invalid_request());
}
Ok(Self {
chains,
routes,
legs,
path_tokens,
warnings,
})
}
#[must_use]
pub const fn chains(self) -> u16 {
self.chains
}
#[must_use]
pub const fn routes(self) -> u16 {
self.routes
}
#[must_use]
pub const fn legs(self) -> u16 {
self.legs
}
#[must_use]
pub const fn path_tokens(self) -> u16 {
self.path_tokens
}
#[must_use]
pub const fn warnings(self) -> u16 {
self.warnings
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct LimitFields {
chains: u16,
routes: u16,
legs: u16,
path_tokens: u16,
warnings: u16,
}
impl TryFrom<LimitFields> for Limits {
type Error = Error;
fn try_from(v: LimitFields) -> Result<Self, Error> {
Self::new(v.chains, v.routes, v.legs, v.path_tokens, v.warnings)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteRequestData {
pub source: Asset,
pub destination: Asset,
pub amount: Amount,
pub slippage: SlippageBps,
pub calculation_timeout: u8,
pub referrer: Identifier,
pub excluded_providers: Vec<Identifier>,
pub preferred_provider: Option<Identifier>,
pub allow_dangerous_routes: bool,
pub skip_fee_providers: bool,
pub sender: Option<Account>,
pub receiver: Option<Account>,
pub integrator: Option<crate::domain::Address>,
pub limits: Limits,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteRequestData", into = "QuoteRequestData")]
pub struct QuoteRequest(QuoteRequestData);
impl QuoteRequest {
pub fn new(v: QuoteRequestData) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if v.amount.raw().is_zero()
|| v.amount.decimals() != Some(v.source.decimals())
|| !(2..=60).contains(&v.calculation_timeout)
|| v.source == v.destination
|| v.excluded_providers.len() > 128
|| v.excluded_providers.iter().any(|p| !ids.insert(p.clone()))
|| v.preferred_provider
.as_ref()
.is_some_and(|p| v.excluded_providers.contains(p))
{
return Err(super::invalid_request());
}
if let Some(a) = &v.sender {
a.validate(v.source.chain())?;
}
if let Some(a) = &v.receiver {
a.validate(v.destination.chain())?;
}
if v.integrator.is_some() && !matches!(v.source.chain().family(), super::Family::Evm { .. })
{
return Err(super::invalid_request());
}
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &QuoteRequestData {
&self.0
}
}
impl TryFrom<QuoteRequestData> for QuoteRequest {
type Error = Error;
fn try_from(v: QuoteRequestData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<QuoteRequest> for QuoteRequestData {
fn from(v: QuoteRequest) -> Self {
v.0
}
}