use super::{Context, Label, Operation, OperationValue, QuoteRequest};
use crate::{
domain::{ExactDecimal, solana::Pubkey},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Router {
Metis,
JupiterZ,
Dflow,
Okx,
}
impl Router {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Metis => "metis",
Self::JupiterZ => "jupiterz",
Self::Dflow => "dflow",
Self::Okx => "okx",
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RouteStepData {
pub amm: Pubkey,
pub label: Label,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub in_amount: u64,
pub out_amount: u64,
pub percent: ExactDecimal,
pub bps: u16,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RouteStepData", into = "RouteStepData")]
pub struct RouteStep(RouteStepData);
impl RouteStep {
pub fn new(data: RouteStepData) -> Result<Self, Error> {
if data.input_mint == data.output_mint
|| data.percent.is_negative()
|| data.percent > ExactDecimal::parse("100")?
|| data.bps > 10_000
{
return Err(invalid());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &RouteStepData {
&self.0
}
}
impl TryFrom<RouteStepData> for RouteStep {
type Error = Error;
fn try_from(v: RouteStepData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<RouteStep> for RouteStepData {
fn from(v: RouteStep) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteFees {
pub total_fee_bps: Option<u16>,
pub platform_fee_bps: Option<u16>,
pub fee_mint: Option<Pubkey>,
pub platform_fee_mint: Option<Pubkey>,
pub platform_fee_amount: Option<u64>,
pub signature_fee_lamports: Option<u64>,
pub priority_fee_lamports: Option<u64>,
pub rent_fee_lamports: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SourceValidity {
pub expires_at_literal: Option<ExpiryLiteral>,
pub last_valid_block_height: Option<u64>,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct ExpiryLiteral(String);
impl ExpiryLiteral {
pub fn new(value: &str) -> Result<Self, Error> {
if value.is_empty() || value.len() > 128 || value.chars().any(char::is_control) {
return Err(invalid());
}
Ok(Self(value.into()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for ExpiryLiteral {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ExpiryLiteral").finish_non_exhaustive()
}
}
impl TryFrom<String> for ExpiryLiteral {
type Error = Error;
fn try_from(value: String) -> Result<Self, Error> {
Self::new(&value)
}
}
impl From<ExpiryLiteral> for String {
fn from(value: ExpiryLiteral) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteData {
pub request: QuoteRequest,
pub router: Router,
pub out_amount: u64,
pub other_amount_threshold: u64,
pub price_impact: ExactDecimal,
pub routes: Vec<RouteStep>,
pub fees: QuoteFees,
pub validity: SourceValidity,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteData", into = "QuoteData")]
pub struct Quote(QuoteData);
impl Quote {
pub fn new(data: QuoteData) -> Result<Self, Error> {
let r = data.request.data();
if r.excluded_routers.contains(&data.router)
|| data.routes.len() > usize::from(r.max_route_steps)
|| data.other_amount_threshold > data.out_amount
|| data.other_amount_threshold < r.slippage.floor(data.out_amount)
|| data.fees.platform_fee_bps.is_some_and(|v| v > 10_000)
|| data.fees.total_fee_bps.is_some_and(|v| v > 10_000)
|| data.router == Router::Metis
&& data
.routes
.iter()
.any(|leg| r.excluded_dexes.contains(&leg.data().label))
{
return Err(invalid());
}
validate_routes(
&data.routes,
r.input_mint,
r.output_mint,
data.router == Router::JupiterZ,
)?;
Ok(Self(data))
}
#[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
}
}
impl OperationValue for Quote {
fn validate_context(&self, c: &Context) -> Result<(), Error> {
if c.operation() != Operation::OrderQuote || c.network() != &self.0.request.data().network {
return Err(invalid());
}
Ok(())
}
}
pub(super) fn validate_routes(
routes: &[RouteStep],
input: Pubkey,
output: Pubkey,
empty_allowed: bool,
) -> Result<(), Error> {
if routes.is_empty() {
return if empty_allowed {
Ok(())
} else {
Err(invalid())
};
}
let mut forward = vec![input];
let mut backward = vec![output];
for _ in 0..routes.len() {
for leg in routes {
let d = leg.data();
if forward.contains(&d.input_mint) && !forward.contains(&d.output_mint) {
forward.push(d.output_mint);
}
if backward.contains(&d.output_mint) && !backward.contains(&d.input_mint) {
backward.push(d.input_mint);
}
}
}
if !forward.contains(&output)
|| routes.iter().any(|leg| {
!forward.contains(&leg.data().input_mint) || !backward.contains(&leg.data().output_mint)
})
{
return Err(invalid());
}
Ok(())
}
fn invalid() -> Error {
ValidationError::InvalidJupiterQuote.into()
}