use super::{Asset, Chain, Identifier, Limits, QuoteRequest, Text};
use crate::{
domain::{Address, Amount, ExactDecimal, market::NonnegativeDecimal},
error::Error,
};
use serde::{Deserialize, Serialize};
use std::collections::BTreeSet;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ChainInfo {
pub alias: Identifier,
pub provider_id: Option<u64>,
pub source_type: Identifier,
pub testnet: bool,
pub proxy_available: bool,
pub cross_chain_providers: Vec<Identifier>,
pub on_chain_providers: Vec<Identifier>,
}
impl ChainInfo {
pub(super) fn validate(&self) -> Result<(), Error> {
if self.provider_id == Some(0)
|| self.cross_chain_providers.len() > 256
|| self.on_chain_providers.len() > 256
{
return Err(super::invalid_quote());
}
for v in [&self.cross_chain_providers, &self.on_chain_providers] {
let mut ids = BTreeSet::new();
if v.iter().any(|p| !ids.insert(p)) {
return Err(super::invalid_quote());
}
}
Ok(())
}
pub fn matches(&self, chain: &Chain) -> Result<(), Error> {
if &self.alias != chain.alias()
|| self.provider_id != chain.provider_id()
|| self.source_type.as_str() != chain.family().source_type()
|| self.testnet != chain.testnet()
{
return Err(super::invalid_identity());
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "Vec<ChainInfo>", into = "Vec<ChainInfo>")]
pub struct Chains(Vec<ChainInfo>);
impl Chains {
pub fn new(v: Vec<ChainInfo>) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if v.len() > 512 || v.iter().any(|c| !ids.insert(c.alias.clone())) {
return Err(super::invalid_quote());
}
for c in &v {
c.validate()?;
}
Ok(Self(v))
}
#[must_use]
pub fn entries(&self) -> &[ChainInfo] {
&self.0
}
}
impl TryFrom<Vec<ChainInfo>> for Chains {
type Error = Error;
fn try_from(v: Vec<ChainInfo>) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Chains> for Vec<ChainInfo> {
fn from(v: Chains) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Token {
pub asset: Asset,
pub symbol: Text,
pub name: Text,
pub price_usd: Option<NonnegativeDecimal>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TokenAmountFields")]
pub struct TokenAmount {
token: Token,
amount: Amount,
}
impl TokenAmount {
pub fn new(token: Token, amount: Amount) -> Result<Self, Error> {
if amount.decimals() != Some(token.asset.decimals()) {
return Err(super::invalid_quote());
}
Ok(Self { token, amount })
}
#[must_use]
pub const fn token(&self) -> &Token {
&self.token
}
#[must_use]
pub const fn amount(&self) -> Amount {
self.amount
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TokenAmountFields {
token: Token,
amount: Amount,
}
impl TryFrom<TokenAmountFields> for TokenAmount {
type Error = Error;
fn try_from(v: TokenAmountFields) -> Result<Self, Error> {
Self::new(v.token, v.amount)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EstimateData {
pub output: Amount,
pub minimum_output: Amount,
pub output_usd: Option<NonnegativeDecimal>,
pub minimum_output_usd: Option<NonnegativeDecimal>,
pub duration_minutes: NonnegativeDecimal,
pub slippage_fraction: NonnegativeDecimal,
pub price_impact: Option<ExactDecimal>,
pub intermediate_raw: Option<Amount>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "EstimateData", into = "EstimateData")]
pub struct Estimate(EstimateData);
impl Estimate {
pub fn new(v: EstimateData) -> Result<Self, Error> {
if v.output.decimals().is_none()
|| v.output.decimals() != v.minimum_output.decimals()
|| v.minimum_output.raw() > v.output.raw()
|| v.intermediate_raw.is_some_and(|a| a.decimals().is_some())
{
return Err(super::invalid_quote());
}
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &EstimateData {
&self.0
}
}
impl TryFrom<EstimateData> for Estimate {
type Error = Error;
fn try_from(v: EstimateData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Estimate> for EstimateData {
fn from(v: Estimate) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GasFees {
pub gas_limit: Option<Amount>,
pub gas_price: Option<Amount>,
pub base_fee: Option<Amount>,
pub max_fee_per_gas: Option<Amount>,
pub max_priority_fee_per_gas: Option<Amount>,
pub total: Option<Amount>,
pub total_usd: Option<NonnegativeDecimal>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FixedFee {
pub amount: Amount,
pub usd: Option<NonnegativeDecimal>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Fees {
pub native_token: Token,
pub gas: GasFees,
pub protocol: FixedFee,
pub provider: FixedFee,
pub percent: NonnegativeDecimal,
pub percent_token: Option<Token>,
}
impl Fees {
pub(super) fn validate(&self, source: &Asset) -> Result<(), Error> {
let decimals = Some(self.native_token.asset.decimals());
if self.native_token.asset.chain() != source.chain()
|| !matches!(
self.native_token.asset.identifier(),
super::AssetIdentifier::Native
)
|| self.protocol.amount.decimals() != decimals
|| self.provider.amount.decimals() != decimals
|| self.gas.total.is_some_and(|a| a.decimals() != decimals)
|| [
self.gas.gas_limit,
self.gas.gas_price,
self.gas.base_fee,
self.gas.max_fee_per_gas,
self.gas.max_priority_fee_per_gas,
]
.iter()
.flatten()
.any(|a| a.decimals().is_some())
{
return Err(super::invalid_quote());
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum LegKind {
OnChain,
CrossChain,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "LegFields")]
pub struct Leg {
kind: LegKind,
provider: Identifier,
path: Vec<TokenAmount>,
}
impl Leg {
pub fn new(kind: LegKind, provider: Identifier, path: Vec<TokenAmount>) -> Result<Self, Error> {
if path.is_empty()
|| path.len() > 128
|| kind == LegKind::OnChain
&& path
.iter()
.any(|t| t.token.asset.chain() != path[0].token.asset.chain())
{
return Err(super::invalid_quote());
}
Ok(Self {
kind,
provider,
path,
})
}
#[must_use]
pub const fn kind(&self) -> LegKind {
self.kind
}
#[must_use]
pub const fn provider(&self) -> &Identifier {
&self.provider
}
#[must_use]
pub fn path(&self) -> &[TokenAmount] {
&self.path
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct LegFields {
kind: LegKind,
provider: Identifier,
path: Vec<TokenAmount>,
}
impl TryFrom<LegFields> for Leg {
type Error = Error;
fn try_from(v: LegFields) -> Result<Self, Error> {
Self::new(v.kind, v.provider, v.path)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum SwapKind {
OnChain,
CrossChain,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Warning {
pub code: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteData {
pub request: QuoteRequest,
pub id: Identifier,
pub input: TokenAmount,
pub destination: Token,
pub provider: Identifier,
pub kind: SwapKind,
pub estimate: Estimate,
pub fees: Fees,
pub legs: Vec<Leg>,
pub warnings: Vec<Warning>,
pub use_rubic_contract: bool,
pub approval_address: Option<Address>,
pub permit2_address: Option<Address>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteData", into = "QuoteData")]
pub struct Quote(QuoteData);
impl Quote {
pub fn new(v: QuoteData) -> Result<Self, Error> {
let r = v.request.data();
if v.input.token.asset != r.source
|| v.destination.asset != r.destination
|| v.estimate.data().output.decimals() != Some(r.destination.decimals())
|| v.estimate.data().slippage_fraction.value()
!= &ExactDecimal::parse(&r.slippage.fraction())?
|| v.kind == SwapKind::OnChain && r.source.chain() != r.destination.chain()
|| v.kind == SwapKind::CrossChain && r.source.chain() == r.destination.chain()
|| r.preferred_provider
.as_ref()
.is_some_and(|p| p != &v.provider)
|| r.excluded_providers.contains(&v.provider)
|| v.legs
.iter()
.any(|l| r.excluded_providers.contains(l.provider()))
|| !matches!(r.source.chain().family(), super::Family::Evm { .. })
&& (v.approval_address.is_some() || v.permit2_address.is_some())
{
return Err(super::invalid_quote());
}
v.fees.validate(&r.source)?;
validate_collections(&v.legs, &v.warnings, r.limits)?;
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &QuoteData {
&self.0
}
}
impl TryFrom<QuoteData> for Quote {
type Error = Error;
fn try_from(v: QuoteData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<Quote> for QuoteData {
fn from(v: Quote) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FreshQuoteData {
pub request: QuoteRequest,
pub id: Identifier,
pub input: Option<TokenAmount>,
pub destination: Option<Token>,
pub provider: Identifier,
pub kind: SwapKind,
pub estimate: Estimate,
pub fees: Fees,
pub legs: Vec<Leg>,
pub warnings: Vec<Warning>,
pub use_rubic_contract: bool,
pub approval_address: Option<Address>,
pub permit2_address: Option<Address>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "FreshQuoteData", into = "FreshQuoteData")]
pub struct FreshQuote(FreshQuoteData);
impl FreshQuote {
pub fn new(v: FreshQuoteData) -> Result<Self, Error> {
let r = v.request.data();
if v.input.as_ref().is_some_and(|t| t.token.asset != r.source)
|| v.destination
.as_ref()
.is_some_and(|t| t.asset != r.destination)
|| v.estimate.data().output.decimals() != Some(r.destination.decimals())
|| v.estimate.data().slippage_fraction.value()
!= &ExactDecimal::parse(&r.slippage.fraction())?
|| v.kind == SwapKind::OnChain && r.source.chain() != r.destination.chain()
|| v.kind == SwapKind::CrossChain && r.source.chain() == r.destination.chain()
|| r.preferred_provider
.as_ref()
.is_some_and(|p| p != &v.provider)
|| r.excluded_providers.contains(&v.provider)
|| v.legs
.iter()
.any(|l| r.excluded_providers.contains(l.provider()))
|| !matches!(r.source.chain().family(), super::Family::Evm { .. })
&& (v.approval_address.is_some() || v.permit2_address.is_some())
{
return Err(super::invalid_quote());
}
v.fees.validate(&r.source)?;
validate_collections(&v.legs, &v.warnings, r.limits)?;
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &FreshQuoteData {
&self.0
}
}
impl TryFrom<FreshQuoteData> for FreshQuote {
type Error = Error;
fn try_from(v: FreshQuoteData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<FreshQuote> for FreshQuoteData {
fn from(v: FreshQuote) -> Self {
v.0
}
}
pub(super) fn validate_collections(
legs: &[Leg],
warnings: &[Warning],
limits: Limits,
) -> Result<(), Error> {
if legs.is_empty()
|| legs.len() > usize::from(limits.legs())
|| legs
.iter()
.any(|l| l.path.len() > usize::from(limits.path_tokens()))
|| warnings.len() > usize::from(limits.warnings())
{
return Err(super::invalid_quote());
}
Ok(())
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RoutesFields")]
pub struct Routes {
request: QuoteRequest,
routes: Vec<Quote>,
}
impl Routes {
pub fn new(request: QuoteRequest, routes: Vec<Quote>) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if routes.len() > usize::from(request.data().limits.routes())
|| routes
.iter()
.any(|q| q.data().request != request || !ids.insert(q.data().id.clone()))
{
return Err(super::invalid_quote());
}
Ok(Self { request, routes })
}
#[must_use]
pub const fn request(&self) -> &QuoteRequest {
&self.request
}
#[must_use]
pub fn routes(&self) -> &[Quote] {
&self.routes
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RoutesFields {
request: QuoteRequest,
routes: Vec<Quote>,
}
impl TryFrom<RoutesFields> for Routes {
type Error = Error;
fn try_from(v: RoutesFields) -> Result<Self, Error> {
Self::new(v.request, v.routes)
}
}