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

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

use crate::{utils::exceptions::ISOCodeException, XRPLSerdeJsonError};

use super::{
    addresscodec::exceptions::XRPLAddressCodecException,
    binarycodec::{
        exceptions::XRPLBinaryCodecException,
        types::exceptions::{
            XRPLHashException, XRPLSerializeArrayException, XRPLSerializeMapException,
            XRPLTypeException, XRPLVectorException, XRPLXChainBridgeException,
        },
    },
    keypairs::exceptions::XRPLKeypairsException,
};

pub type XRPLCoreResult<T, E = XRPLCoreException> = core::result::Result<T, E>;

#[derive(Debug, PartialEq, Error)]
#[non_exhaustive]
pub enum XRPLCoreException {
    #[error("XRPL Address Codec error: {0}")]
    XRPLAddressCodecError(#[from] XRPLAddressCodecException),
    #[error("XRPL Binary Codec error: {0}")]
    XRPLBinaryCodecError(#[from] XRPLBinaryCodecException),
    #[error("XRPL Keypairs error: {0}")]
    XRPLKeypairsError(#[from] XRPLKeypairsException),
    #[error("serde_json error: {0}")]
    SerdeJsonError(#[from] XRPLSerdeJsonError),
    #[error("XRPL utils error: {0}")]
    XRPLUtilsError(String), // TODO: find a better way to avoid infinite recursion
    #[error("From hex error: {0}")]
    FromHexError(#[from] hex::FromHexError),
    #[error("ISO code error: {0}")]
    ISOCodeError(#[from] ISOCodeException),
    #[error("Base58 error: {0}")]
    Bs58Error(#[from] bs58::decode::Error),
}

impl From<XRPLTypeException> for XRPLCoreException {
    fn from(error: XRPLTypeException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(error))
    }
}

impl From<XRPLSerializeArrayException> for XRPLCoreException {
    fn from(error: XRPLSerializeArrayException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(
            XRPLTypeException::XRPLSerializeArrayException(error),
        ))
    }
}

impl From<XRPLSerializeMapException> for XRPLCoreException {
    fn from(error: XRPLSerializeMapException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(
            XRPLTypeException::XRPLSerializeMapException(error),
        ))
    }
}

impl From<XRPLXChainBridgeException> for XRPLCoreException {
    fn from(error: XRPLXChainBridgeException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(
            XRPLTypeException::XRPLXChainBridgeError(error),
        ))
    }
}

impl From<XRPLHashException> for XRPLCoreException {
    fn from(error: XRPLHashException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(
            XRPLTypeException::XRPLHashError(error),
        ))
    }
}

impl From<XRPLVectorException> for XRPLCoreException {
    fn from(error: XRPLVectorException) -> Self {
        XRPLCoreException::XRPLBinaryCodecError(XRPLBinaryCodecException::XRPLTypeError(
            XRPLTypeException::XRPLVectorError(error),
        ))
    }
}

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