use super::PreparedSwap;
use crate::{
domain::solana::{ExecutionObservation, ExecutionRequest, MessageFee, ReadOptions, Simulation},
error::{Error, ValidationError},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "EstimateFields", into = "EstimateFields")]
pub struct SwapEstimate {
prepared: PreparedSwap,
options: ReadOptions,
fee: ExecutionObservation<MessageFee>,
simulation: ExecutionObservation<Simulation>,
}
impl SwapEstimate {
pub fn new(
prepared: PreparedSwap,
options: ReadOptions,
fee: ExecutionObservation<MessageFee>,
simulation: ExecutionObservation<Simulation>,
) -> Result<Self, Error> {
let network = prepared
.intent()
.data()
.build
.value()
.data()
.request
.data()
.network
.genesis_hash();
if fee.context().network().genesis_hash() != network
|| simulation.context().network().genesis_hash() != network
|| !matches!(fee.context().request(),ExecutionRequest::MessageFee{message,options:o} if message==prepared.unsigned().transaction().message() && *o==options)
|| !matches!(simulation.context().request(),ExecutionRequest::Simulation{transaction,options:o} if transaction==prepared.unsigned().transaction() && *o==options)
{
return Err(ValidationError::InvalidJupiterEstimate.into());
}
Ok(Self {
prepared,
options,
fee,
simulation,
})
}
#[must_use]
pub const fn prepared(&self) -> &PreparedSwap {
&self.prepared
}
#[must_use]
pub const fn options(&self) -> ReadOptions {
self.options
}
#[must_use]
pub const fn fee(&self) -> &ExecutionObservation<MessageFee> {
&self.fee
}
#[must_use]
pub const fn simulation(&self) -> &ExecutionObservation<Simulation> {
&self.simulation
}
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct EstimateFields {
prepared: PreparedSwap,
options: ReadOptions,
fee: ExecutionObservation<MessageFee>,
simulation: ExecutionObservation<Simulation>,
}
impl TryFrom<EstimateFields> for SwapEstimate {
type Error = Error;
fn try_from(f: EstimateFields) -> Result<Self, Error> {
Self::new(f.prepared, f.options, f.fee, f.simulation)
}
}
impl From<SwapEstimate> for EstimateFields {
fn from(s: SwapEstimate) -> Self {
Self {
prepared: s.prepared,
options: s.options,
fee: s.fee,
simulation: s.simulation,
}
}
}