use super::{
BuildRequest, Context, Instruction, LookupTable, Operation, OperationValue, RouteStep,
quote::validate_routes,
};
use crate::{
domain::{
ExactDecimal,
solana::{Hash, Pubkey},
},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TimeFields", into = "TimeFields")]
pub struct FetchedAt {
seconds: u64,
nanoseconds: u32,
}
impl FetchedAt {
pub fn new(seconds: u64, nanoseconds: u32) -> Result<Self, Error> {
if nanoseconds >= 1_000_000_000 {
return Err(invalid());
}
Ok(Self {
seconds,
nanoseconds,
})
}
#[must_use]
pub const fn seconds(self) -> u64 {
self.seconds
}
#[must_use]
pub const fn nanoseconds(self) -> u32 {
self.nanoseconds
}
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct TimeFields {
seconds: u64,
nanoseconds: u32,
}
impl TryFrom<TimeFields> for FetchedAt {
type Error = Error;
fn try_from(v: TimeFields) -> Result<Self, Error> {
Self::new(v.seconds, v.nanoseconds)
}
}
impl From<FetchedAt> for TimeFields {
fn from(v: FetchedAt) -> Self {
Self {
seconds: v.seconds,
nanoseconds: v.nanoseconds,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SwapBuildData {
pub request: BuildRequest,
pub out_amount: u64,
pub other_amount_threshold: u64,
pub price_impact: ExactDecimal,
pub routes: Vec<RouteStep>,
pub compute_budget: Vec<Instruction>,
pub setup: Vec<Instruction>,
pub swap: Instruction,
pub cleanup: Option<Instruction>,
pub other: Vec<Instruction>,
pub lookup_tables: Vec<LookupTable>,
pub blockhash: Hash,
pub last_valid_block_height: u64,
pub blockhash_fetched_at: FetchedAt,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SwapBuildData", into = "SwapBuildData")]
pub struct SwapBuild(SwapBuildData);
impl SwapBuild {
pub const MAX_LOOKUP_TABLES: usize = 64;
pub const MAX_INSTRUCTIONS: usize = 64;
pub fn new(data: SwapBuildData) -> Result<Self, Error> {
let r = data.request.data();
if data.other_amount_threshold < data.request.data().minimum_output
|| data.other_amount_threshold > data.out_amount
|| data.other_amount_threshold < r.slippage.floor(data.out_amount)
|| data.routes.len() > usize::from(r.max_route_steps)
|| data.lookup_tables.len() > Self::MAX_LOOKUP_TABLES
|| data.compute_budget.len()
+ data.setup.len()
+ data.other.len()
+ usize::from(data.cleanup.is_some())
+ 1
> Self::MAX_INSTRUCTIONS
|| data.swap.fields().program_id
!= Pubkey::parse("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4")?
|| data.lookup_tables.iter().enumerate().any(|(i, t)| {
data.lookup_tables[..i]
.iter()
.any(|p| p.address() == t.address())
})
|| data.routes.iter().any(|leg| match &r.dex_filter {
super::DexFilter::All => false,
super::DexFilter::Include(labels) => !labels.contains(&leg.data().label),
super::DexFilter::Exclude(labels) => labels.contains(&leg.data().label),
})
{
return Err(invalid());
}
validate_routes(&data.routes, r.input_mint, r.output_mint, false)?;
let result = Self(data);
super::preparation::price(&result).map_err(|_| invalid())?;
Ok(result)
}
#[must_use]
pub const fn data(&self) -> &SwapBuildData {
&self.0
}
pub fn compute_unit_price(&self) -> Result<u64, Error> {
super::preparation::price(self)
}
}
impl TryFrom<SwapBuildData> for SwapBuild {
type Error = Error;
fn try_from(v: SwapBuildData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<SwapBuild> for SwapBuildData {
fn from(v: SwapBuild) -> Self {
v.0
}
}
impl OperationValue for SwapBuild {
fn validate_context(&self, c: &Context) -> Result<(), Error> {
if c.operation() != Operation::Build || c.network() != &self.0.request.data().network {
return Err(invalid());
}
Ok(())
}
}
fn invalid() -> Error {
ValidationError::InvalidJupiterBuild.into()
}