use super::{Chain, Identifier, TransactionId};
use crate::error::Error;
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ProviderStatus {
Pending,
LongPending,
NotFound,
Revert,
Reverted,
ReadyToClaim,
Success,
Fail,
KycRequired,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "QueryFields")]
pub struct StatusQuery {
id: Identifier,
source: Chain,
source_transaction: TransactionId,
destination: Chain,
}
impl StatusQuery {
pub fn new(
id: Identifier,
source: Chain,
source_transaction: TransactionId,
destination: Chain,
) -> Result<Self, Error> {
source_transaction.validate(&source)?;
Ok(Self {
id,
source,
source_transaction,
destination,
})
}
#[must_use]
pub const fn id(&self) -> &Identifier {
&self.id
}
#[must_use]
pub const fn source(&self) -> &Chain {
&self.source
}
#[must_use]
pub const fn source_transaction(&self) -> &TransactionId {
&self.source_transaction
}
#[must_use]
pub const fn destination(&self) -> &Chain {
&self.destination
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct QueryFields {
id: Identifier,
source: Chain,
source_transaction: TransactionId,
destination: Chain,
}
impl TryFrom<QueryFields> for StatusQuery {
type Error = Error;
fn try_from(v: QueryFields) -> Result<Self, Error> {
Self::new(v.id, v.source, v.source_transaction, v.destination)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "DestinationFields")]
pub struct DestinationTransaction {
chain: Chain,
id: TransactionId,
}
impl DestinationTransaction {
pub fn new(chain: Chain, id: TransactionId) -> Result<Self, Error> {
id.validate(&chain)?;
Ok(Self { chain, id })
}
#[must_use]
pub const fn chain(&self) -> &Chain {
&self.chain
}
#[must_use]
pub const fn id(&self) -> &TransactionId {
&self.id
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct DestinationFields {
chain: Chain,
id: TransactionId,
}
impl TryFrom<DestinationFields> for DestinationTransaction {
type Error = Error;
fn try_from(v: DestinationFields) -> Result<Self, Error> {
Self::new(v.chain, v.id)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StatusFields")]
pub struct Status {
query: StatusQuery,
#[serde(rename = "status")]
state: ProviderStatus,
destination: Option<DestinationTransaction>,
final_human_amount: Option<crate::domain::market::NonnegativeDecimal>,
final_raw_amount: Option<crate::domain::Amount>,
#[serde(rename = "sub_status")]
detail: Option<super::Text>,
}
impl Status {
pub fn new(
query: StatusQuery,
status: ProviderStatus,
destination: Option<DestinationTransaction>,
final_human_amount: Option<crate::domain::market::NonnegativeDecimal>,
final_raw_amount: Option<crate::domain::Amount>,
sub_status: Option<super::Text>,
) -> Result<Self, Error> {
if destination
.as_ref()
.is_some_and(|d| d.chain() != query.destination())
|| final_raw_amount.is_some_and(|a| a.decimals().is_some())
{
return Err(super::invalid_status());
}
Ok(Self {
query,
state: status,
destination,
final_human_amount,
final_raw_amount,
detail: sub_status,
})
}
#[must_use]
pub const fn query(&self) -> &StatusQuery {
&self.query
}
#[must_use]
pub const fn status(&self) -> ProviderStatus {
self.state
}
#[must_use]
pub const fn destination(&self) -> Option<&DestinationTransaction> {
self.destination.as_ref()
}
#[must_use]
pub const fn final_human_amount(&self) -> Option<&crate::domain::market::NonnegativeDecimal> {
self.final_human_amount.as_ref()
}
#[must_use]
pub const fn final_raw_amount(&self) -> Option<crate::domain::Amount> {
self.final_raw_amount
}
#[must_use]
pub const fn sub_status(&self) -> Option<&super::Text> {
self.detail.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StatusFields {
query: StatusQuery,
status: ProviderStatus,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
destination: Option<DestinationTransaction>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
final_human_amount: Option<crate::domain::market::NonnegativeDecimal>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
final_raw_amount: Option<crate::domain::Amount>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
sub_status: Option<super::Text>,
}
impl TryFrom<StatusFields> for Status {
type Error = Error;
fn try_from(v: StatusFields) -> Result<Self, Error> {
Self::new(
v.query,
v.status,
v.destination,
v.final_human_amount,
v.final_raw_amount,
v.sub_status,
)
}
}