use super::invalid_request;
use crate::{
domain::{Address, ChainId, NetworkId, U256, evm::Quantity},
error::Error,
};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "contract",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum AssetKind {
Native,
Erc20(Address),
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "AssetFields")]
pub struct Asset {
chain_id: ChainId,
kind: AssetKind,
}
impl Asset {
pub fn new(chain_id: ChainId, kind: AssetKind) -> Result<Self, Error> {
if chain_id.value().is_zero()
|| matches!(kind,AssetKind::Erc20(a) if a.bytes()==[0;20] || a.bytes()==[0xee;20])
{
return Err(invalid_request());
}
Ok(Self { chain_id, kind })
}
#[must_use]
pub const fn chain_id(self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn kind(self) -> AssetKind {
self.kind
}
#[must_use]
pub fn provider_address(self) -> Address {
match self.kind {
AssetKind::Native => Address::from_bytes([0xee; 20]),
AssetKind::Erc20(a) => a,
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct AssetFields {
chain_id: ChainId,
kind: AssetKind,
}
impl TryFrom<AssetFields> for Asset {
type Error = Error;
fn try_from(v: AssetFields) -> Result<Self, Error> {
Self::new(v.chain_id, v.kind)
}
}
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct ProtocolId(String);
impl ProtocolId {
pub fn new(text: impl Into<String>) -> Result<Self, Error> {
let text = text.into();
if text.is_empty()
|| text.len() > 128
|| !text
.bytes()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-' | b'.'))
{
return Err(invalid_request());
}
Ok(Self(text))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<String> for ProtocolId {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<ProtocolId> for String {
fn from(v: ProtocolId) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct SourceText(String);
impl SourceText {
pub fn new(v: impl Into<String>) -> Result<Self, Error> {
let v = v.into();
if v.len() > 4096 {
return Err(invalid_request());
}
Ok(Self(v))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl TryFrom<String> for SourceText {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<SourceText> for String {
fn from(v: SourceText) -> Self {
v.0
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "LimitFields")]
pub struct Limits {
route_items: u16,
liquidity_sources: u16,
}
impl Limits {
pub fn new(route_items: u16, liquidity_sources: u16) -> Result<Self, Error> {
if !(1..=4096).contains(&route_items) || !(1..=512).contains(&liquidity_sources) {
return Err(invalid_request());
}
Ok(Self {
route_items,
liquidity_sources,
})
}
#[must_use]
pub const fn route_items(self) -> u16 {
self.route_items
}
#[must_use]
pub const fn liquidity_sources(self) -> u16 {
self.liquidity_sources
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct LimitFields {
route_items: u16,
liquidity_sources: u16,
}
impl TryFrom<LimitFields> for Limits {
type Error = Error;
fn try_from(v: LimitFields) -> Result<Self, Error> {
Self::new(v.route_items, v.liquidity_sources)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteSettings {
#[serde(deserialize_with = "protocols")]
pub protocols: Vec<ProtocolId>,
#[serde(deserialize_with = "protocols")]
pub excluded_protocols: Vec<ProtocolId>,
#[serde(deserialize_with = "connectors")]
pub connector_tokens: Vec<Asset>,
pub gas_price: Option<Quantity>,
pub complexity_level: Option<u8>,
pub parts: Option<u8>,
pub main_route_parts: Option<u8>,
pub gas_limit: Option<u64>,
}
fn protocols<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<ProtocolId>, D::Error> {
super::bounded::<D, ProtocolId, 64>(d)
}
fn connectors<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<Asset>, D::Error> {
super::bounded::<D, Asset, 64>(d)
}
impl QuoteSettings {
#[must_use]
pub const fn provider_defaults() -> Self {
Self {
protocols: Vec::new(),
excluded_protocols: Vec::new(),
connector_tokens: Vec::new(),
gas_price: None,
complexity_level: None,
parts: None,
main_route_parts: None,
gas_limit: None,
}
}
fn validate(&self, chain: ChainId) -> Result<(), Error> {
let included: HashSet<_> = self.protocols.iter().collect();
let excluded: HashSet<_> = self.excluded_protocols.iter().collect();
let connectors: HashSet<_> = self.connector_tokens.iter().collect();
if self.protocols.len() > 64
|| self.excluded_protocols.len() > 64
|| self.connector_tokens.len() > 64
|| included.len() != self.protocols.len()
|| excluded.len() != self.excluded_protocols.len()
|| !included.is_disjoint(&excluded)
|| connectors.len() != self.connector_tokens.len()
|| self.connector_tokens.iter().any(|a| a.chain_id() != chain)
|| self.complexity_level.is_some_and(|n| n > 3)
|| self.parts.is_some_and(|n| n == 0 || n > 100)
|| self.main_route_parts.is_some_and(|n| n == 0 || n > 100)
|| self.gas_limit == Some(0)
{
return Err(invalid_request());
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteRequestFields")]
pub struct QuoteRequest {
network: NetworkId,
source: Asset,
destination: Asset,
amount: Quantity,
settings: QuoteSettings,
}
impl QuoteRequest {
pub fn new(
network: NetworkId,
source: Asset,
destination: Asset,
amount: Quantity,
settings: QuoteSettings,
) -> Result<Self, Error> {
if source.chain_id() != network.chain_id()
|| destination.chain_id() != network.chain_id()
|| source == destination
|| amount.value().is_zero()
{
return Err(invalid_request());
}
settings.validate(network.chain_id())?;
Ok(Self {
network,
source,
destination,
amount,
settings,
})
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub const fn source(&self) -> Asset {
self.source
}
#[must_use]
pub const fn destination(&self) -> Asset {
self.destination
}
#[must_use]
pub const fn amount(&self) -> Quantity {
self.amount
}
#[must_use]
pub const fn settings(&self) -> &QuoteSettings {
&self.settings
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct QuoteRequestFields {
network: NetworkId,
source: Asset,
destination: Asset,
amount: Quantity,
settings: QuoteSettings,
}
impl TryFrom<QuoteRequestFields> for QuoteRequest {
type Error = Error;
fn try_from(v: QuoteRequestFields) -> Result<Self, Error> {
Self::new(v.network, v.source, v.destination, v.amount, v.settings)
}
}
#[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(invalid_request());
}
Ok(Self(v))
}
#[must_use]
pub const fn value(self) -> u16 {
self.0
}
#[must_use]
pub fn percent(self) -> String {
format!("{}.{:02}", self.0 / 100, self.0 % 100)
}
}
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(
tag = "kind",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum ReturnPolicy {
Minimum(Quantity),
Slippage(SlippageBps),
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SwapSettings {
pub from: Address,
pub origin: Address,
pub recipient: Address,
pub output_floor: Quantity,
pub return_policy: ReturnPolicy,
pub router: Address,
pub spender: Address,
pub native_value: Quantity,
pub disable_estimate: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SwapRequestFields")]
pub struct SwapRequest {
selection: super::Quote,
settings: SwapSettings,
}
impl SwapRequest {
pub fn new(selection: super::Quote, settings: SwapSettings) -> Result<Self, Error> {
if [
settings.from,
settings.origin,
settings.recipient,
settings.router,
settings.spender,
]
.iter()
.any(|a| a.bytes() == [0; 20] || a.bytes() == [0xee; 20])
|| settings.output_floor.value().is_zero()
|| settings.output_floor.value() > selection.data().destination_amount.value()
|| matches!(settings.return_policy,ReturnPolicy::Minimum(q)if q!=settings.output_floor)
{
return Err(invalid_request());
}
if selection.data().source_token.fee_on_transfer == Some(true)
|| selection.data().destination_token.fee_on_transfer == Some(true)
{
return Err(Error::UnsupportedCapability);
}
let native = if selection.request().source().kind() == AssetKind::Native {
selection.request().amount()
} else {
Quantity::new(U256::ZERO)
};
if settings.native_value != native {
return Err(invalid_request());
}
Ok(Self {
selection,
settings,
})
}
#[must_use]
pub const fn selection(&self) -> &super::Quote {
&self.selection
}
#[must_use]
pub const fn settings(&self) -> &SwapSettings {
&self.settings
}
#[must_use]
pub fn network(&self) -> &NetworkId {
self.selection.request().network()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SwapRequestFields {
selection: super::Quote,
settings: SwapSettings,
}
impl TryFrom<SwapRequestFields> for SwapRequest {
type Error = Error;
fn try_from(v: SwapRequestFields) -> Result<Self, Error> {
Self::new(v.selection, v.settings)
}
}