use std::{collections::BTreeSet, fmt};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use sha2::{Digest, Sha512};
use crate::error::{Error, ValidationError};
use super::{Address, Hash, Ledger};
fn invalid_record() -> Error {
ValidationError::InvalidXrplRecord.into()
}
#[derive(Clone, Eq, PartialEq)]
pub struct HexData(Vec<u8>);
impl HexData {
pub const MAX_BYTES: usize = 1_048_576;
pub fn parse(text: &str) -> Result<Self, Error> {
if text.is_empty()
|| text.len() > Self::MAX_BYTES * 2
|| !text.len().is_multiple_of(2)
|| !text.bytes().all(|byte| byte.is_ascii_hexdigit())
{
return Err(invalid_record());
}
const_hex::decode(text)
.map(Self)
.map_err(|_| invalid_record())
}
#[must_use]
pub fn bytes(&self) -> &[u8] {
&self.0
}
#[must_use]
pub fn to_hex(&self) -> String {
const_hex::encode_upper(&self.0)
}
#[must_use]
pub fn transaction_hash(&self) -> Hash {
let mut digest = Sha512::new();
digest.update(b"TXN\0");
digest.update(&self.0);
let full = digest.finalize();
let mut bytes = [0; 32];
bytes.copy_from_slice(&full[..32]);
Hash::from_bytes(bytes)
}
}
impl fmt::Debug for HexData {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HexData")
.field("byte_length", &self.0.len())
.finish_non_exhaustive()
}
}
impl Serialize for HexData {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&self.to_hex())
}
}
impl<'de> Deserialize<'de> for HexData {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(transparent)]
pub struct ResultCode(String);
impl ResultCode {
pub fn parse(code: &str) -> Result<Self, Error> {
let valid = code == "tesSUCCESS"
|| code.strip_prefix("tec").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 is_success(&self) -> bool {
self.0 == "tesSUCCESS"
}
}
impl<'de> Deserialize<'de> for ResultCode {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::parse(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StatusFields")]
pub struct TransactionStatus {
hash: Hash,
ledger: Option<Ledger>,
execution: Option<ResultCode>,
}
impl TransactionStatus {
pub fn new(
hash: Hash,
ledger: Option<Ledger>,
execution: Option<ResultCode>,
) -> Result<Self, Error> {
if ledger.is_some_and(Ledger::validated) && execution.is_none()
|| execution.is_some() && ledger.is_none()
{
return Err(invalid_record());
}
Ok(Self {
hash,
ledger,
execution,
})
}
#[must_use]
pub const fn hash(&self) -> Hash {
self.hash
}
#[must_use]
pub const fn ledger(&self) -> Option<Ledger> {
self.ledger
}
#[must_use]
pub const fn execution(&self) -> Option<&ResultCode> {
self.execution.as_ref()
}
#[must_use]
pub fn validated(&self) -> bool {
self.ledger.is_some_and(Ledger::validated)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StatusFields {
hash: Hash,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
ledger: Option<Ledger>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
execution: Option<ResultCode>,
}
impl TryFrom<StatusFields> for TransactionStatus {
type Error = Error;
fn try_from(v: StatusFields) -> Result<Self, Error> {
Self::new(v.hash, v.ledger, v.execution)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct Transaction {
hash: Hash,
payload: HexData,
metadata: Option<HexData>,
ledger: Option<Ledger>,
}
impl Transaction {
pub fn new(
hash: Hash,
payload: HexData,
metadata: Option<HexData>,
ledger: Option<Ledger>,
) -> Result<Self, Error> {
if payload.transaction_hash() != hash
|| ledger.is_some_and(Ledger::validated) && metadata.is_none()
|| metadata.is_some() && ledger.is_none()
{
return Err(invalid_record());
}
Ok(Self {
hash,
payload,
metadata,
ledger,
})
}
#[must_use]
pub const fn hash(&self) -> Hash {
self.hash
}
#[must_use]
pub const fn payload(&self) -> &HexData {
&self.payload
}
#[must_use]
pub const fn metadata(&self) -> Option<&HexData> {
self.metadata.as_ref()
}
#[must_use]
pub const fn ledger(&self) -> Option<Ledger> {
self.ledger
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
hash: Hash,
payload: HexData,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
metadata: Option<HexData>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
ledger: Option<Ledger>,
}
impl TryFrom<TransactionFields> for Transaction {
type Error = Error;
fn try_from(v: TransactionFields) -> Result<Self, Error> {
Self::new(v.hash, v.payload, v.metadata, v.ledger)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RangeFields")]
pub struct LedgerRange {
minimum: u32,
maximum: u32,
}
impl LedgerRange {
pub const fn new(minimum: u32, maximum: u32) -> Result<Self, Error> {
if minimum == 0 || maximum < minimum {
return Err(Error::Validation(ValidationError::InvalidPageRequest));
}
Ok(Self { minimum, maximum })
}
#[must_use]
pub const fn minimum(self) -> u32 {
self.minimum
}
#[must_use]
pub const fn maximum(self) -> u32 {
self.maximum
}
fn contains(self, index: u32) -> bool {
(self.minimum..=self.maximum).contains(&index)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RangeFields {
minimum: u32,
maximum: u32,
}
impl TryFrom<RangeFields> for LedgerRange {
type Error = Error;
fn try_from(v: RangeFields) -> Result<Self, Error> {
Self::new(v.minimum, v.maximum)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "CursorFields")]
pub struct HistoryMarker {
ledger: u32,
seq: u32,
}
impl HistoryMarker {
pub const fn new(ledger: u32, seq: u32) -> Result<Self, Error> {
if ledger == 0 {
return Err(Error::Validation(ValidationError::InvalidPageRequest));
}
Ok(Self { ledger, seq })
}
#[must_use]
pub const fn ledger(self) -> u32 {
self.ledger
}
#[must_use]
pub const fn sequence(self) -> u32 {
self.seq
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct CursorFields {
ledger: u32,
seq: u32,
}
impl TryFrom<CursorFields> for HistoryMarker {
type Error = Error;
fn try_from(v: CursorFields) -> Result<Self, Error> {
Self::new(v.ledger, v.seq)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryRequestFields")]
pub struct HistoryRequest {
range: LedgerRange,
limit: u16,
forward: bool,
marker: Option<HistoryMarker>,
}
impl HistoryRequest {
pub fn new(
range: LedgerRange,
limit: u16,
forward: bool,
marker: Option<HistoryMarker>,
) -> Result<Self, Error> {
if !(1..=400).contains(&limit)
|| marker.is_some_and(|cursor| !range.contains(cursor.ledger()))
{
return Err(ValidationError::InvalidPageRequest.into());
}
Ok(Self {
range,
limit,
forward,
marker,
})
}
#[must_use]
pub const fn range(&self) -> LedgerRange {
self.range
}
#[must_use]
pub const fn limit(&self) -> u16 {
self.limit
}
#[must_use]
pub const fn forward(&self) -> bool {
self.forward
}
#[must_use]
pub const fn marker(&self) -> Option<HistoryMarker> {
self.marker
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryRequestFields {
range: LedgerRange,
limit: u16,
forward: bool,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
marker: Option<HistoryMarker>,
}
impl TryFrom<HistoryRequestFields> for HistoryRequest {
type Error = Error;
fn try_from(v: HistoryRequestFields) -> Result<Self, Error> {
Self::new(v.range, v.limit, v.forward, v.marker)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryFields")]
pub struct HistoryPage {
account: Address,
request: HistoryRequest,
searched: LedgerRange,
transactions: Vec<Transaction>,
next: Option<HistoryMarker>,
}
impl HistoryPage {
pub fn new(
account: Address,
request: HistoryRequest,
searched: LedgerRange,
transactions: Vec<Transaction>,
next: Option<HistoryMarker>,
) -> Result<Self, Error> {
let requested = request.range();
let mut hashes = BTreeSet::new();
if transactions.len() > usize::from(request.limit())
|| searched.minimum() < requested.minimum()
|| searched.maximum() > requested.maximum()
|| transactions.iter().any(|tx| {
!hashes.insert(tx.hash())
|| !tx.ledger().is_some_and(|ledger| {
ledger.validated() && searched.contains(ledger.index())
})
})
|| next.is_some_and(|marker| {
Some(marker) == request.marker() || !searched.contains(marker.ledger())
})
{
return Err(invalid_record());
}
Ok(Self {
account,
request,
searched,
transactions,
next,
})
}
#[must_use]
pub const fn account(&self) -> Address {
self.account
}
#[must_use]
pub const fn request(&self) -> &HistoryRequest {
&self.request
}
#[must_use]
pub const fn searched(&self) -> LedgerRange {
self.searched
}
#[must_use]
pub fn transactions(&self) -> &[Transaction] {
&self.transactions
}
#[must_use]
pub const fn next_marker(&self) -> Option<HistoryMarker> {
self.next
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryFields {
account: Address,
request: HistoryRequest,
searched: LedgerRange,
transactions: Vec<Transaction>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
next: Option<HistoryMarker>,
}
impl TryFrom<HistoryFields> for HistoryPage {
type Error = Error;
fn try_from(v: HistoryFields) -> Result<Self, Error> {
Self::new(v.account, v.request, v.searched, v.transactions, v.next)
}
}