use super::{Account, Chain, Family, FreshQuote, Identifier, Quote};
use crate::{
domain::{
Address, Amount,
evm::{Data, Quantity},
solana::{Pubkey, UnsignedTransaction},
},
error::Error,
wallets::Preparation,
};
use serde::{Deserialize, Serialize};
use std::{collections::BTreeSet, fmt};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PreparationRequestData {
pub quote: Quote,
pub sender: Account,
pub receiver: Account,
pub minimum_output: Amount,
pub maximum_native_value: Amount,
pub expected_evm_router: Option<Address>,
pub expected_approval: Option<Address>,
pub expected_permit2: Option<Address>,
pub expected_solana_signers: Vec<Pubkey>,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PreparationRequestData", into = "PreparationRequestData")]
pub struct PreparationRequest(PreparationRequestData);
impl PreparationRequest {
pub fn new(v: PreparationRequestData) -> Result<Self, Error> {
let q = v.quote.data();
let r = q.request.data();
v.sender.validate(r.source.chain())?;
v.receiver.validate(r.destination.chain())?;
if r.sender.as_ref().is_some_and(|a| a != &v.sender)
|| r.receiver.as_ref().is_some_and(|a| a != &v.receiver)
|| v.minimum_output.decimals() != Some(r.destination.decimals())
|| v.maximum_native_value.decimals() != Some(q.fees.native_token.asset.decimals())
|| v.expected_approval != q.approval_address
|| v.expected_permit2 != q.permit2_address
{
return Err(super::invalid_preparation());
}
match r.source.chain().family() {
Family::Evm { .. } => {
if v.expected_evm_router.is_none() || !v.expected_solana_signers.is_empty() {
return Err(super::invalid_preparation());
}
}
Family::Solana { .. } => {
let mut ids = BTreeSet::new();
if v.expected_evm_router.is_some()
|| v.expected_approval.is_some()
|| v.expected_permit2.is_some()
|| v.expected_solana_signers.is_empty()
|| v.expected_solana_signers.len() > 16
|| v.expected_solana_signers
.iter()
.any(|p| !ids.insert(p.to_string()))
|| !matches!(&v.sender,Account::Solana(p) if v.expected_solana_signers.first()==Some(p))
{
return Err(super::invalid_preparation());
}
}
Family::Provider { .. } => return Err(Error::UnsupportedCapability),
}
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &PreparationRequestData {
&self.0
}
}
impl fmt::Debug for PreparationRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PreparationRequest").finish_non_exhaustive()
}
}
impl TryFrom<PreparationRequestData> for PreparationRequest {
type Error = Error;
fn try_from(v: PreparationRequestData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<PreparationRequest> for PreparationRequestData {
fn from(v: PreparationRequest) -> Self {
v.0
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EvmPayload {
pub to: Address,
pub value: Quantity,
pub input: Data,
}
impl fmt::Debug for EvmPayload {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("EvmPayload").finish_non_exhaustive()
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "family",
content = "payload",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum Payload {
Evm(EvmPayload),
Solana(UnsignedTransaction),
}
impl fmt::Debug for Payload {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Payload").finish_non_exhaustive()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ForeignFields")]
pub struct ForeignFilters {
provider: Identifier,
excluded: Vec<super::Text>,
}
impl ForeignFilters {
pub fn new(provider: Identifier, excluded: Vec<super::Text>) -> Result<Self, Error> {
let mut ids = BTreeSet::new();
if excluded.len() > 128 || excluded.iter().any(|p| !ids.insert(p.as_str())) {
return Err(super::invalid_preparation());
}
Ok(Self { provider, excluded })
}
#[must_use]
pub const fn provider(&self) -> &Identifier {
&self.provider
}
#[must_use]
pub fn excluded(&self) -> &[super::Text] {
&self.excluded
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ForeignFields {
provider: Identifier,
excluded: Vec<super::Text>,
}
impl TryFrom<ForeignFields> for ForeignFilters {
type Error = Error;
fn try_from(v: ForeignFields) -> Result<Self, Error> {
Self::new(v.provider, v.excluded)
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PreparedSwapData {
pub request: PreparationRequest,
pub fresh_quote: FreshQuote,
pub source_integrator: Option<Address>,
pub source_foreign_filters: Vec<ForeignFilters>,
pub source_provider_ids: Vec<SourceId>,
pub source_additional_data: Option<SourceAdditionalData>,
pub payload: Payload,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PreparedSwapData", into = "PreparedSwapData")]
pub struct PreparedSwap(PreparedSwapData);
impl PreparedSwap {
pub fn new(v: PreparedSwapData) -> Result<Self, Error> {
let req = v.request.data();
let old = req.quote.data();
let fresh = v.fresh_quote.data();
let r = old.request.data();
let mut ids = BTreeSet::new();
if fresh.request != old.request
|| fresh.id != old.id
|| fresh.provider != old.provider
|| fresh.kind != old.kind
|| fresh.approval_address != req.expected_approval
|| fresh.permit2_address != req.expected_permit2
|| fresh.estimate.data().minimum_output.raw() < req.minimum_output.raw()
|| r.integrator.is_some_and(|a| Some(a) != v.source_integrator)
|| v.source_foreign_filters.len() > 16
|| v.source_foreign_filters
.iter()
.any(|p| !ids.insert(p.provider.clone()))
|| v.source_provider_ids.len() > 32
|| !crate::domain::market::unique(v.source_provider_ids.iter().map(|p| &p.kind))
{
return Err(super::invalid_preparation());
}
match (&v.payload, r.source.chain().family()) {
(Payload::Evm(p), Family::Evm { .. }) => {
if Some(p.to) != req.expected_evm_router
|| p.value.value() > req.maximum_native_value.raw()
|| p.input.bytes().is_empty()
{
return Err(super::invalid_preparation());
}
}
(Payload::Solana(p), Family::Solana { .. }) => {
let keys = p.message().static_accounts();
let count = usize::from(p.message().required_signatures());
if keys.get(..count) != Some(req.expected_solana_signers.as_slice()) {
return Err(super::invalid_preparation());
}
}
_ => return Err(super::invalid_preparation()),
}
Ok(Self(v))
}
#[must_use]
pub const fn data(&self) -> &PreparedSwapData {
&self.0
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "String", into = "String")]
pub struct SourceAdditionalData(String);
impl SourceAdditionalData {
pub fn new(value: &str) -> Result<Self, Error> {
super::json::additional_object(value).map_err(|_| super::invalid_preparation())?;
Ok(Self(value.into()))
}
#[must_use]
pub fn as_json(&self) -> &str {
&self.0
}
}
impl fmt::Debug for SourceAdditionalData {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SourceAdditionalData")
.finish_non_exhaustive()
}
}
impl TryFrom<String> for SourceAdditionalData {
type Error = Error;
fn try_from(value: String) -> Result<Self, Error> {
Self::new(&value)
}
}
impl From<SourceAdditionalData> for String {
fn from(value: SourceAdditionalData) -> Self {
value.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SourceId {
pub kind: Identifier,
pub value: super::Text,
}
impl fmt::Debug for PreparedSwap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PreparedSwap").finish_non_exhaustive()
}
}
impl fmt::Debug for PreparedSwapData {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PreparedSwapData").finish_non_exhaustive()
}
}
impl TryFrom<PreparedSwapData> for PreparedSwap {
type Error = Error;
fn try_from(v: PreparedSwapData) -> Result<Self, Error> {
Self::new(v)
}
}
impl From<PreparedSwap> for PreparedSwapData {
fn from(v: PreparedSwap) -> Self {
v.0
}
}
impl Preparation for PreparedSwap {
type Network = Chain;
type Intent = PreparedSwapData;
type UnsignedPayload = Payload;
fn network(&self) -> &Chain {
self.0
.request
.data()
.quote
.data()
.request
.data()
.source
.chain()
}
fn intent(&self) -> &PreparedSwapData {
&self.0
}
fn unsigned_payload(&self) -> &Payload {
&self.0.payload
}
fn validate(&self) -> Result<(), Error> {
Self::new(self.0.clone()).map(|_| ())
}
}