cdk-payment-processor 0.16.0

CDK payment processor
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

//! Error for payment processor

use thiserror::Error;
use tonic::Status;

/// CDK Payment processor error
#[derive(Debug, Error)]
pub enum Error {
    /// Invalid ID
    #[error("Invalid id")]
    InvalidId,
    /// Invalid payment identifier
    #[error("Invalid payment identifier")]
    InvalidPaymentIdentifier,
    /// Invalid hash
    #[error("Invalid hash")]
    InvalidHash,
    /// Invalid currency unit
    #[error("Invalid currency unit: {0}")]
    InvalidCurrencyUnit(String),
    /// Missing amount field
    #[error("Missing amount field")]
    MissingAmount,
    /// Parse invoice error
    #[error(transparent)]
    Invoice(#[from] lightning_invoice::ParseOrSemanticError),
    /// Hex decode error
    #[error(transparent)]
    Hex(#[from] hex::FromHexError),
    /// BOLT12 parse error
    #[error("BOLT12 parse error")]
    Bolt12Parse,
    /// NUT00 Error
    #[error(transparent)]
    NUT00(#[from] cdk_common::nuts::nut00::Error),
    /// NUT05 error
    #[error(transparent)]
    NUT05(#[from] cdk_common::nuts::nut05::Error),
    /// Payment error
    #[error(transparent)]
    Payment(#[from] cdk_common::payment::Error),
}

impl From<Error> for Status {
    fn from(error: Error) -> Self {
        match error {
            Error::InvalidId => Status::invalid_argument("Invalid ID"),
            Error::InvalidPaymentIdentifier => {
                Status::invalid_argument("Invalid payment identifier")
            }
            Error::InvalidHash => Status::invalid_argument("Invalid hash"),
            Error::InvalidCurrencyUnit(unit) => {
                Status::invalid_argument(format!("Invalid currency unit: {unit}"))
            }
            Error::MissingAmount => Status::invalid_argument("Missing amount field"),
            Error::Invoice(err) => Status::invalid_argument(format!("Invoice error: {err}")),
            Error::Hex(err) => Status::invalid_argument(format!("Hex decode error: {err}")),
            Error::Bolt12Parse => Status::invalid_argument("BOLT12 parse error"),
            Error::NUT00(err) => Status::internal(format!("NUT00 error: {err}")),
            Error::NUT05(err) => Status::internal(format!("NUT05 error: {err}")),
            Error::Payment(err) => Status::internal(format!("Payment error: {err}")),
        }
    }
}

impl From<Error> for cdk_common::payment::Error {
    fn from(error: Error) -> Self {
        match error {
            Error::InvalidId => Self::Custom("Invalid ID".to_string()),
            Error::InvalidPaymentIdentifier => {
                Self::Custom("Invalid payment identifier".to_string())
            }
            Error::InvalidHash => Self::Custom("Invalid hash".to_string()),
            Error::InvalidCurrencyUnit(unit) => {
                Self::Custom(format!("Invalid currency unit: {unit}"))
            }
            Error::MissingAmount => Self::Custom("Missing amount field".to_string()),
            Error::Invoice(err) => Self::Custom(format!("Invoice error: {err}")),
            Error::Hex(err) => Self::Custom(format!("Hex decode error: {err}")),
            Error::Bolt12Parse => Self::Custom("BOLT12 parse error".to_string()),
            Error::NUT00(err) => Self::Custom(format!("NUT00 error: {err}")),
            Error::NUT05(err) => err.into(),
            Error::Payment(err) => err,
        }
    }
}