use serde::{Deserialize, Deserializer, Serialize};
use crate::error::{Error, ValidationError};
use super::{Drops, Hash, HexData, NetworkId, Setting};
fn invalid_record() -> Error {
ValidationError::InvalidXrplRecord.into()
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SignedFields")]
pub struct SignedSubmission {
network: NetworkId,
payload: HexData,
hash: Hash,
fail_hard: bool,
}
impl SignedSubmission {
#[must_use]
pub fn new(network: NetworkId, payload: HexData, fail_hard: bool) -> Self {
let hash = payload.transaction_hash();
Self {
network,
payload,
hash,
fail_hard,
}
}
#[must_use]
pub const fn network(&self) -> NetworkId {
self.network
}
#[must_use]
pub const fn payload(&self) -> &HexData {
&self.payload
}
#[must_use]
pub const fn hash(&self) -> Hash {
self.hash
}
#[must_use]
pub const fn fail_hard(&self) -> bool {
self.fail_hard
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SignedFields {
network: NetworkId,
payload: HexData,
hash: Hash,
fail_hard: bool,
}
impl TryFrom<SignedFields> for SignedSubmission {
type Error = Error;
fn try_from(v: SignedFields) -> Result<Self, Error> {
let submission = Self::new(v.network, v.payload, v.fail_hard);
if submission.hash() != v.hash {
return Err(invalid_record());
}
Ok(submission)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EngineResultClass {
Success,
ClaimedCost,
Failure,
LocalError,
Malformed,
Retry,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(transparent)]
pub struct EngineResultCode(String);
impl EngineResultCode {
pub fn parse(code: &str) -> Result<Self, Error> {
let valid = code == "tesSUCCESS"
|| ["tec", "tef", "tel", "tem", "ter"].iter().any(|prefix| {
code.strip_prefix(prefix).is_some_and(|suffix| {
!suffix.is_empty()
&& suffix
.bytes()
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_')
})
});
if !valid || code.len() > 64 {
return Err(invalid_record());
}
Ok(Self(code.into()))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn class(&self) -> EngineResultClass {
match self.0.get(..3) {
Some("tec") => EngineResultClass::ClaimedCost,
Some("tef") => EngineResultClass::Failure,
Some("tel") => EngineResultClass::LocalError,
Some("tem") => EngineResultClass::Malformed,
Some("ter") => EngineResultClass::Retry,
_ => EngineResultClass::Success,
}
}
}
impl<'de> Deserialize<'de> for EngineResultCode {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HandlingFields")]
pub struct SubmissionHandling {
accepted: Setting,
applied: Setting,
broadcast: Setting,
kept: Setting,
queued: Setting,
}
impl SubmissionHandling {
pub fn new(
accepted: Setting,
applied: Setting,
broadcast: Setting,
kept: Setting,
queued: Setting,
) -> Result<Self, Error> {
if (accepted == Setting::Enabled)
!= [applied, broadcast, kept, queued].contains(&Setting::Enabled)
{
return Err(invalid_record());
}
Ok(Self {
accepted,
applied,
broadcast,
kept,
queued,
})
}
#[must_use]
pub const fn accepted(self) -> Setting {
self.accepted
}
#[must_use]
pub const fn applied(self) -> Setting {
self.applied
}
#[must_use]
pub const fn broadcast(self) -> Setting {
self.broadcast
}
#[must_use]
pub const fn kept(self) -> Setting {
self.kept
}
#[must_use]
pub const fn queued(self) -> Setting {
self.queued
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HandlingFields {
accepted: Setting,
applied: Setting,
broadcast: Setting,
kept: Setting,
queued: Setting,
}
impl TryFrom<HandlingFields> for SubmissionHandling {
type Error = Error;
fn try_from(v: HandlingFields) -> Result<Self, Error> {
Self::new(v.accepted, v.applied, v.broadcast, v.kept, v.queued)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StateFields")]
pub struct SubmissionLedgerState {
account_sequence_available: u32,
account_sequence_next: u32,
open_ledger_cost: Drops,
latest_validated_ledger_index: u32,
}
impl SubmissionLedgerState {
pub const fn new(
account_sequence_available: u32,
account_sequence_next: u32,
open_ledger_cost: Drops,
latest_validated_ledger_index: u32,
) -> Result<Self, Error> {
if latest_validated_ledger_index == 0 {
return Err(Error::Validation(ValidationError::InvalidXrplRecord));
}
Ok(Self {
account_sequence_available,
account_sequence_next,
open_ledger_cost,
latest_validated_ledger_index,
})
}
#[must_use]
pub const fn account_sequence_available(self) -> u32 {
self.account_sequence_available
}
#[must_use]
pub const fn account_sequence_next(self) -> u32 {
self.account_sequence_next
}
#[must_use]
pub const fn open_ledger_cost(self) -> Drops {
self.open_ledger_cost
}
#[must_use]
pub const fn latest_validated_ledger_index(self) -> u32 {
self.latest_validated_ledger_index
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StateFields {
account_sequence_available: u32,
account_sequence_next: u32,
open_ledger_cost: Drops,
latest_validated_ledger_index: u32,
}
impl TryFrom<StateFields> for SubmissionLedgerState {
type Error = Error;
fn try_from(v: StateFields) -> Result<Self, Error> {
Self::new(
v.account_sequence_available,
v.account_sequence_next,
v.open_ledger_cost,
v.latest_validated_ledger_index,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SubmissionResult {
hash: Hash,
engine_result: EngineResultCode,
handling: SubmissionHandling,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
ledger_state: Option<SubmissionLedgerState>,
}
impl SubmissionResult {
#[must_use]
pub const fn new(
hash: Hash,
engine_result: EngineResultCode,
handling: SubmissionHandling,
ledger_state: Option<SubmissionLedgerState>,
) -> Self {
Self {
hash,
engine_result,
handling,
ledger_state,
}
}
#[must_use]
pub const fn hash(&self) -> Hash {
self.hash
}
#[must_use]
pub const fn engine_result(&self) -> &EngineResultCode {
&self.engine_result
}
#[must_use]
pub const fn handling(&self) -> SubmissionHandling {
self.handling
}
#[must_use]
pub const fn ledger_state(&self) -> Option<SubmissionLedgerState> {
self.ledger_state
}
}