use serde::{Deserialize, Serialize};
use crate::error::{Error, ValidationError};
use super::{
Address, Currency, Drops, IssuedValue, Network, NetworkId, XAddress, XAddressCategory,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Destination {
network: NetworkId,
address: Address,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
tag: Option<u32>,
}
impl Destination {
#[must_use]
pub const fn new(network: NetworkId, address: Address, tag: Option<u32>) -> Self {
Self {
network,
address,
tag,
}
}
pub const fn from_xaddress(
network: NetworkId,
value: XAddress,
category: XAddressCategory,
) -> Result<Self, Error> {
if value.is_test() != matches!(category, XAddressCategory::Test) {
return Err(Error::Validation(ValidationError::InvalidXrplNetwork));
}
Ok(Self::new(network, value.address(), value.tag()))
}
#[must_use]
pub const fn network(self) -> NetworkId {
self.network
}
#[must_use]
pub const fn address(self) -> Address {
self.address
}
#[must_use]
pub const fn tag(self) -> Option<u32> {
self.tag
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(untagged, deny_unknown_fields)]
pub enum PaymentAmount {
Xrp(Drops),
Issued {
currency: Currency,
issuer: Address,
value: IssuedValue,
},
}
impl PaymentAmount {
fn positive(&self) -> bool {
match self {
Self::Xrp(drops) => drops.raw() != 0,
Self::Issued { value, .. } => !value.value().is_zero() && !value.value().is_negative(),
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RequestFields")]
pub struct PaymentRequest {
network: Network,
account: Address,
destination: Destination,
amount: PaymentAmount,
fee: Drops,
sequence: u32,
last_ledger_sequence: u32,
}
impl PaymentRequest {
pub fn new(
network: Network,
account: Address,
destination: Destination,
amount: PaymentAmount,
fee: Drops,
sequence: u32,
last_ledger_sequence: u32,
) -> Result<Self, Error> {
if network.identity() != destination.network() {
return Err(ValidationError::NetworkMismatch.into());
}
if account == destination.address()
|| !amount.positive()
|| fee.raw() == 0
|| sequence == 0
|| last_ledger_sequence == 0
{
return Err(ValidationError::InvalidXrplRecord.into());
}
Ok(Self {
network,
account,
destination,
amount,
fee,
sequence,
last_ledger_sequence,
})
}
#[must_use]
pub const fn network(&self) -> &Network {
&self.network
}
#[must_use]
pub const fn account(&self) -> Address {
self.account
}
#[must_use]
pub const fn destination(&self) -> Destination {
self.destination
}
#[must_use]
pub const fn amount(&self) -> &PaymentAmount {
&self.amount
}
#[must_use]
pub const fn fee(&self) -> Drops {
self.fee
}
#[must_use]
pub const fn sequence(&self) -> u32 {
self.sequence
}
#[must_use]
pub const fn last_ledger_sequence(&self) -> u32 {
self.last_ledger_sequence
}
#[must_use]
pub fn prepare(self) -> PreparedPayment {
PreparedPayment(self)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RequestFields {
network: Network,
account: Address,
destination: Destination,
amount: PaymentAmount,
fee: Drops,
sequence: u32,
last_ledger_sequence: u32,
}
impl TryFrom<RequestFields> for PaymentRequest {
type Error = Error;
fn try_from(v: RequestFields) -> Result<Self, Error> {
Self::new(
v.network,
v.account,
v.destination,
v.amount,
v.fee,
v.sequence,
v.last_ledger_sequence,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct PreparedPayment(PaymentRequest);
impl PreparedPayment {
#[must_use]
pub const fn request(&self) -> &PaymentRequest {
&self.0
}
}
#[derive(Serialize)]
#[serde(rename_all = "PascalCase")]
struct UnsignedFields<'a> {
transaction_type: &'static str,
account: Address,
destination: Address,
#[serde(skip_serializing_if = "Option::is_none")]
destination_tag: Option<u32>,
amount: &'a PaymentAmount,
fee: Drops,
sequence: u32,
last_ledger_sequence: u32,
#[serde(rename = "NetworkID", skip_serializing_if = "Option::is_none")]
network_id: Option<u32>,
}
impl Serialize for PreparedPayment {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let request = &self.0;
let number = request.network().identity().number();
UnsignedFields {
transaction_type: "Payment",
account: request.account(),
destination: request.destination().address(),
destination_tag: request.destination().tag(),
amount: request.amount(),
fee: request.fee(),
sequence: request.sequence(),
last_ledger_sequence: request.last_ledger_sequence(),
network_id: (number > 1024).then_some(number),
}
.serialize(serializer)
}
}