xrpl-rust 1.1.0

A 100% Rust library to interact with the XRPL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Exception for invalid XRP Ledger amount data.

use alloc::string::String;
use thiserror_no_std::Error;

#[cfg(feature = "models")]
use crate::models::XRPLModelException;
use crate::{core::exceptions::XRPLCoreException, XRPLSerdeJsonError};

pub type XRPLUtilsResult<T, E = XRPLUtilsException> = core::result::Result<T, E>;

#[derive(Debug, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLUtilsException {
    #[error("XRPL Time Range error: {0}")]
    XRPLTimeRangeError(#[from] XRPLTimeRangeException),
    #[error("XRP Range error: {0}")]
    XRPRangeError(#[from] XRPRangeException),
    #[error("XRPL NFT ID error: {0}")]
    XRPLNFTIdError(#[from] XRPLNFTIdException),
    #[error("XRPL Core error: {0}")]
    XRPLCoreError(#[from] XRPLCoreException),
    #[cfg(feature = "models")]
    #[error("XRPL Model error: {0}")]
    XRPLModelError(#[from] XRPLModelException),
    #[error("XRPL Txn Parser error: {0}")]
    XRPLTxnParserError(#[from] XRPLTxnParserException),
    #[error("XRPL XChain Claim ID error: {0}")]
    XRPLXChainClaimIdError(#[from] XRPLXChainClaimIdException),
    #[error("ISO Code error: {0}")]
    ISOCodeError(#[from] ISOCodeException),
    #[error("Decimal error: {0}")]
    DecimalError(#[from] rust_decimal::Error),
    #[error("BigDecimal error: {0}")]
    BigDecimalError(#[from] bigdecimal::ParseBigDecimalError),
    #[error("serde_json error: {0}")]
    SerdeJsonError(#[from] XRPLSerdeJsonError),
    #[error("From Hex error: {0}")]
    FromHexError(#[from] hex::FromHexError),
    #[error("ParseInt error: {0}")]
    ParseIntError(#[from] core::num::ParseIntError),
    #[error("Invalid UTF-8")]
    Utf8Error,
}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLTimeRangeException {
    #[error("Invalid time before epoch (min: {min} found: {found})")]
    InvalidTimeBeforeEpoch { min: i64, found: i64 },
    #[error("Invalid time after epoch (max: {max} found: {found})")]
    UnexpectedTimeOverflow { max: i64, found: i64 },
    #[error("Invalid local time")]
    InvalidLocalTime,
}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPRangeException {
    #[error("Invalid XRP amount")]
    InvalidXRPAmount,
    #[error("Invalid Issued Currency amount")]
    InvalidICAmount,
    #[error("Invalid value contains decimal")]
    InvalidValueContainsDecimal,
    #[error("Invalid XRP amount too small (min: {min} found: {found})")]
    InvalidXRPAmountTooSmall { min: String, found: String },
    #[error("Invalid XRP amount too large (max: {max} found: {found})")]
    InvalidXRPAmountTooLarge { max: u64, found: String },
    #[error("Invalid Issued Currency precision too small (min: {min} found: {found})")]
    InvalidICPrecisionTooSmall { min: i32, found: i32 },
    #[error("Invalid Issued Currency precision too large (max: {max} found: {found})")]
    InvalidICPrecisionTooLarge { max: i32, found: i32 },
    #[error("Invalid Drops amount too large (max: {max} found: {found})")]
    InvalidDropsAmountTooLarge { max: String, found: String },
    #[error("Invalid Issued Currency serialization length (expected: {expected} found: {found})")]
    InvalidICSerializationLength { expected: usize, found: usize },
    #[error("Invalid Issued Currency amount overflow (max: {max} found: {found})")]
    UnexpectedICAmountOverflow { max: usize, found: usize },
}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLNFTIdException {
    #[error("Invalid NFT ID length (expected: {expected} found: {found})")]
    InvalidNFTIdLength { expected: usize, found: usize },
}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLXChainClaimIdException {
    #[error("No XChainOwnedClaimID created")]
    NoXChainOwnedClaimID,
}

#[cfg(feature = "std")]
impl alloc::error::Error for XRPLXChainClaimIdException {}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLTxnParserException {
    #[error("Missing field: {0}")]
    MissingField(&'static str),
}

#[cfg(feature = "std")]
impl alloc::error::Error for XRPLTxnParserException {}

#[derive(Debug, Clone, PartialEq, Error)]
#[non_exhaustive]
pub enum ISOCodeException {
    #[error("Invalid ISO code")]
    InvalidISOCode,
    #[error("Invalid ISO length")]
    InvalidISOLength,
    #[error("Invalid XRP bytes")]
    InvalidXRPBytes,
    #[error("Invalid Currency representation")]
    UnsupportedCurrencyRepresentation,
}

impl From<core::str::Utf8Error> for XRPLUtilsException {
    fn from(_: core::str::Utf8Error) -> Self {
        XRPLUtilsException::Utf8Error
    }
}

impl From<serde_json::Error> for XRPLUtilsException {
    fn from(error: serde_json::Error) -> Self {
        XRPLUtilsException::SerdeJsonError(error.into())
    }
}

#[cfg(feature = "std")]
impl alloc::error::Error for XRPLTimeRangeException {}

#[cfg(feature = "std")]
impl alloc::error::Error for XRPRangeException {}

#[cfg(feature = "std")]
impl alloc::error::Error for ISOCodeException {}

#[cfg(feature = "std")]
impl alloc::error::Error for XRPLUtilsException {}