use super::{Method, Quote, Spender, SwapRequest, invalid_payload};
use crate::{
domain::{
Address, NetworkId,
evm::{Data, Quantity},
},
error::Error,
wallets::Preparation,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SourceTransactionData {
pub from: Address,
pub to: Address,
pub data: Data,
pub value: Quantity,
pub gas_price: Quantity,
pub gas: Quantity,
pub gas_used: Option<Quantity>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct SourceTransaction {
network: NetworkId,
data: SourceTransactionData,
}
impl SourceTransaction {
pub fn new(network: NetworkId, data: SourceTransactionData) -> Result<Self, Error> {
if data.data.bytes().len() < 4
|| network.chain_id().value().is_zero()
|| data.data.bytes().len() > 65_536
|| data.from.bytes() == [0; 20]
|| data.to.bytes() == [0; 20]
|| data.from.bytes() == [0xee; 20]
|| data.to.bytes() == [0xee; 20]
|| data.gas.value().is_zero()
{
return Err(invalid_payload());
}
Ok(Self { network, data })
}
#[must_use]
pub const fn network(&self) -> &NetworkId {
&self.network
}
#[must_use]
pub const fn data(&self) -> &SourceTransactionData {
&self.data
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
network: NetworkId,
data: SourceTransactionData,
}
impl TryFrom<TransactionFields> for SourceTransaction {
type Error = Error;
fn try_from(v: TransactionFields) -> Result<Self, Error> {
Self::new(v.network, v.data)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PreparedFields")]
pub struct PreparedSwap {
request: SwapRequest,
fresh_quote: Quote,
transaction: SourceTransaction,
spender: Spender,
}
impl PreparedSwap {
pub fn new(
request: SwapRequest,
fresh_quote: Quote,
transaction: SourceTransaction,
spender: Spender,
) -> Result<Self, Error> {
let settings = request.settings();
if fresh_quote.request() != request.selection().request()
|| fresh_quote.context().method != Method::Swap
|| transaction.network() != request.network()
|| transaction.data().from != settings.from
|| transaction.data().to != settings.router
|| transaction.data().value != settings.native_value
|| &spender.context().network != request.network()
|| spender.address() != settings.spender
|| fresh_quote.data().destination_amount.value() < settings.output_floor.value()
{
return Err(invalid_payload());
}
if fresh_quote.data().source_token.fee_on_transfer == Some(true)
|| fresh_quote.data().destination_token.fee_on_transfer == Some(true)
{
return Err(Error::UnsupportedCapability);
}
Ok(Self {
request,
fresh_quote,
transaction,
spender,
})
}
#[must_use]
pub const fn request(&self) -> &SwapRequest {
&self.request
}
#[must_use]
pub const fn fresh_quote(&self) -> &Quote {
&self.fresh_quote
}
#[must_use]
pub const fn transaction(&self) -> &SourceTransaction {
&self.transaction
}
#[must_use]
pub const fn spender(&self) -> &Spender {
&self.spender
}
}
impl Preparation for PreparedSwap {
type Network = NetworkId;
type Intent = SwapRequest;
type UnsignedPayload = SourceTransaction;
fn network(&self) -> &NetworkId {
self.request.network()
}
fn intent(&self) -> &SwapRequest {
&self.request
}
fn unsigned_payload(&self) -> &SourceTransaction {
&self.transaction
}
fn validate(&self) -> Result<(), Error> {
Self::new(
self.request.clone(),
self.fresh_quote.clone(),
self.transaction.clone(),
self.spender.clone(),
)
.map(|_| ())
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct PreparedFields {
request: SwapRequest,
fresh_quote: Quote,
transaction: SourceTransaction,
spender: Spender,
}
impl TryFrom<PreparedFields> for PreparedSwap {
type Error = Error;
fn try_from(v: PreparedFields) -> Result<Self, Error> {
Self::new(v.request, v.fresh_quote, v.transaction, v.spender)
}
}