use super::Router;
use crate::{
domain::solana::{Hash, Network, Pubkey},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
use std::fmt;
pub fn mainnet(alias: &str) -> Result<Network, Error> {
Network::new(
Hash::parse("5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d")?,
alias,
)
}
pub(super) fn validate_network(network: &Network) -> Result<(), Error> {
if network.genesis_hash() != mainnet("mainnet")?.genesis_hash() {
return Err(invalid());
}
Ok(())
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct Label(String);
impl Label {
pub fn new(value: &str) -> Result<Self, Error> {
if value.is_empty() || value.len() > 64 || value.chars().any(|c| c.is_control() || c == ',')
{
return Err(invalid());
}
Ok(Self(value.into()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Label {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Label").finish_non_exhaustive()
}
}
impl TryFrom<String> for Label {
type Error = Error;
fn try_from(v: String) -> Result<Self, Error> {
Self::new(&v)
}
}
impl From<Label> for String {
fn from(v: Label) -> Self {
v.0
}
}
#[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 > 10_000 {
return Err(invalid());
}
Ok(Self(v))
}
#[must_use]
pub const fn value(self) -> u16 {
self.0
}
pub(super) fn floor(self, out: u64) -> u64 {
let retained = u64::from(10_000 - self.0);
out / 10_000 * retained + (out % 10_000) * retained / 10_000
}
}
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, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuoteRequestData {
pub network: Network,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub amount: u64,
pub slippage: SlippageBps,
pub excluded_routers: Vec<Router>,
pub excluded_dexes: Vec<Label>,
pub max_route_steps: u16,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QuoteRequestData", into = "QuoteRequestData")]
pub struct QuoteRequest(QuoteRequestData);
impl QuoteRequest {
pub fn new(data: QuoteRequestData) -> Result<Self, Error> {
validate_network(&data.network)?;
if data.amount == 0
|| data.input_mint == data.output_mint
|| !(1..=128).contains(&data.max_route_steps)
|| data.excluded_routers.len() > 3
|| data
.excluded_routers
.iter()
.enumerate()
.any(|(i, v)| data.excluded_routers[..i].contains(v))
{
return Err(invalid());
}
validate_labels(&data.excluded_dexes)?;
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &QuoteRequestData {
&self.0
}
}
impl TryFrom<QuoteRequestData> for QuoteRequest {
type Error = Error;
fn try_from(v: QuoteRequestData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<QuoteRequest> for QuoteRequestData {
fn from(v: QuoteRequest) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "labels",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum DexFilter {
All,
Include(Vec<Label>),
Exclude(Vec<Label>),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum Destination {
Taker,
TokenAccount {
address: Pubkey,
},
Native {
address: Pubkey,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BuildRequestData {
pub network: Network,
pub input_mint: Pubkey,
pub output_mint: Pubkey,
pub amount: u64,
pub taker: Pubkey,
pub payer: Pubkey,
pub slippage: SlippageBps,
pub minimum_output: u64,
pub wrap_and_unwrap_sol: bool,
pub destination: Destination,
pub dex_filter: DexFilter,
pub max_accounts: u8,
pub blockhash_slots_to_expiry: u16,
pub compute_unit_price_percentile: u16,
pub max_route_steps: u16,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "BuildRequestData", into = "BuildRequestData")]
pub struct BuildRequest(BuildRequestData);
impl BuildRequest {
pub fn new(data: BuildRequestData) -> Result<Self, Error> {
validate_network(&data.network)?;
if data.amount == 0
|| data.input_mint == data.output_mint
|| !(1..=64).contains(&data.max_accounts)
|| !(1..=300).contains(&data.blockhash_slots_to_expiry)
|| data.compute_unit_price_percentile > 10_000
|| !(1..=128).contains(&data.max_route_steps)
{
return Err(invalid());
}
if let Destination::Native { .. } = data.destination
&& (!data.wrap_and_unwrap_sol
|| data.output_mint
!= Pubkey::parse("So11111111111111111111111111111111111111112")?)
{
return Err(invalid());
}
if let DexFilter::Include(labels) | DexFilter::Exclude(labels) = &data.dex_filter {
if labels.is_empty() {
return Err(invalid());
}
validate_labels(labels)?;
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &BuildRequestData {
&self.0
}
}
impl TryFrom<BuildRequestData> for BuildRequest {
type Error = Error;
fn try_from(v: BuildRequestData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<BuildRequest> for BuildRequestData {
fn from(v: BuildRequest) -> Self {
v.0
}
}
fn validate_labels(labels: &[Label]) -> Result<(), Error> {
if labels.len() > 32
|| labels
.iter()
.enumerate()
.any(|(i, v)| labels[..i].contains(v))
{
return Err(invalid());
}
Ok(())
}
fn invalid() -> Error {
ValidationError::InvalidJupiterRequest.into()
}