use super::{Asset, Limits, ProtocolId, QuoteRequest, SourceText, invalid_record};
use crate::{
domain::{ExactDecimal, NetworkId, Source, Timestamp, evm::Quantity},
error::Error,
};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Method {
Quote,
Swap,
LiquiditySources,
Spender,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Context {
pub network: NetworkId,
pub method: Method,
pub source: Source,
pub retrieved_at: Timestamp,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Expiry {
Unreported,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StateOverrides {
Unreported,
Null,
Empty,
PresentUninterpreted,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Token {
pub asset: Asset,
pub decimals: u8,
pub symbol: SourceText,
pub name: SourceText,
pub fee_on_transfer: Option<bool>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ProtocolShare {
pub name: ProtocolId,
pub percent: ExactDecimal,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Hop {
pub destination: Asset,
pub from_token_id: u32,
pub to_token_id: u32,
pub percent: ExactDecimal,
#[serde(deserialize_with = "protocol_shares")]
pub protocols: Vec<ProtocolShare>,
}
fn protocol_shares<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<ProtocolShare>, D::Error> {
super::bounded::<D, ProtocolShare, 256>(d)
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TokenSwaps {
pub token: Asset,
#[serde(deserialize_with = "hops")]
pub hops: Vec<Hop>,
}
fn hops<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<Hop>, D::Error> {
super::bounded::<D, Hop, 256>(d)
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "GraphFields")]
pub struct RouteGraph {
network: NetworkId,
groups: Vec<TokenSwaps>,
}
impl RouteGraph {
pub fn new(network: NetworkId, groups: Vec<TokenSwaps>) -> Result<Self, Error> {
if groups.len() > 64 || network.chain_id().value().is_zero() {
return Err(invalid_record());
}
let mut ids = HashMap::new();
let mut count = groups.len();
for group in &groups {
if group.token.chain_id() != network.chain_id() || group.hops.len() > 256 {
return Err(invalid_record());
}
count += group.hops.len();
for hop in &group.hops {
if hop.destination.chain_id() != network.chain_id() || hop.protocols.len() > 256 {
return Err(invalid_record());
}
share(&hop.percent)?;
for (id, asset) in [
(hop.from_token_id, group.token),
(hop.to_token_id, hop.destination),
] {
if ids
.insert(id, asset)
.is_some_and(|previous| previous != asset)
{
return Err(invalid_record());
}
}
count += hop.protocols.len();
for protocol in &hop.protocols {
share(&protocol.percent)?;
}
}
}
if count > 4096 {
return Err(invalid_record());
}
Ok(Self { network, groups })
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub fn groups(&self) -> &[TokenSwaps] {
&self.groups
}
#[must_use]
pub fn item_count(&self) -> usize {
self.groups.len()
+ self
.groups
.iter()
.map(|g| g.hops.len() + g.hops.iter().map(|h| h.protocols.len()).sum::<usize>())
.sum::<usize>()
}
pub fn check_limits(&self, limits: Limits) -> Result<(), Error> {
if self.item_count() > usize::from(limits.route_items()) {
return Err(invalid_record());
}
Ok(())
}
}
fn share(v: &ExactDecimal) -> Result<(), Error> {
if v.is_negative() || v > &ExactDecimal::parse("100")? {
return Err(invalid_record());
}
Ok(())
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct GraphFields {
network: NetworkId,
#[serde(deserialize_with = "groups")]
groups: Vec<TokenSwaps>,
}
fn groups<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<TokenSwaps>, D::Error> {
super::bounded::<D, TokenSwaps, 64>(d)
}
impl TryFrom<GraphFields> for RouteGraph {
type Error = Error;
fn try_from(v: GraphFields) -> Result<Self, Error> {
Self::new(v.network, v.groups)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteData {
pub source_token: Token,
pub destination_token: Token,
pub destination_amount: Quantity,
pub routes: RouteGraph,
pub estimated_gas: Option<Quantity>,
pub expiry: Expiry,
pub state_overrides: StateOverrides,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteFields")]
pub struct Quote {
request: QuoteRequest,
data: QuoteData,
context: Context,
}
impl Quote {
pub fn new(request: QuoteRequest, data: QuoteData, context: Context) -> Result<Self, Error> {
if &context.network != request.network()
|| !matches!(context.method, Method::Quote | Method::Swap)
|| data.source_token.asset != request.source()
|| data.destination_token.asset != request.destination()
|| data.routes.network() != request.network()
{
return Err(invalid_record());
}
let settings = request.settings();
if data
.routes
.groups()
.iter()
.flat_map(|group| &group.hops)
.flat_map(|hop| &hop.protocols)
.any(|share| {
settings.excluded_protocols.contains(&share.name)
|| (!settings.protocols.is_empty() && !settings.protocols.contains(&share.name))
})
{
return Err(invalid_record());
}
Ok(Self {
request,
data,
context,
})
}
#[must_use]
pub const fn request(&self) -> &QuoteRequest {
&self.request
}
#[must_use]
pub const fn data(&self) -> &QuoteData {
&self.data
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct QuoteFields {
request: QuoteRequest,
data: QuoteData,
context: Context,
}
impl TryFrom<QuoteFields> for Quote {
type Error = Error;
fn try_from(v: QuoteFields) -> Result<Self, Error> {
Self::new(v.request, v.data, v.context)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LiquiditySource {
pub id: ProtocolId,
pub title: SourceText,
pub image: SourceText,
pub image_color: SourceText,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SourcesFields")]
pub struct LiquiditySources {
context: Context,
items: Vec<LiquiditySource>,
}
impl LiquiditySources {
pub fn new(context: Context, items: Vec<LiquiditySource>) -> Result<Self, Error> {
let ids: HashSet<_> = items.iter().map(|v| &v.id).collect();
if context.method != Method::LiquiditySources
|| context.network.chain_id().value().is_zero()
|| items.len() > 512
|| ids.len() != items.len()
{
return Err(invalid_record());
}
Ok(Self { context, items })
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
#[must_use]
pub fn items(&self) -> &[LiquiditySource] {
&self.items
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SourcesFields {
context: Context,
#[serde(deserialize_with = "sources")]
items: Vec<LiquiditySource>,
}
fn sources<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<LiquiditySource>, D::Error> {
super::bounded::<D, LiquiditySource, 512>(d)
}
impl TryFrom<SourcesFields> for LiquiditySources {
type Error = Error;
fn try_from(v: SourcesFields) -> Result<Self, Error> {
Self::new(v.context, v.items)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SpenderFields")]
pub struct Spender {
context: Context,
address: crate::domain::Address,
}
impl Spender {
pub fn new(context: Context, address: crate::domain::Address) -> Result<Self, Error> {
if context.method != Method::Spender
|| context.network.chain_id().value().is_zero()
|| (address.bytes() == [0; 20] || address.bytes() == [0xee; 20])
{
return Err(invalid_record());
}
Ok(Self { context, address })
}
#[must_use]
pub const fn context(&self) -> &Context {
&self.context
}
#[must_use]
pub const fn address(&self) -> crate::domain::Address {
self.address
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SpenderFields {
context: Context,
address: crate::domain::Address,
}
impl TryFrom<SpenderFields> for Spender {
type Error = Error;
fn try_from(v: SpenderFields) -> Result<Self, Error> {
Self::new(v.context, v.address)
}
}