bright-ln-models 0.1.0

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LndInvoiceRequest {
    form: String,
}
impl LndInvoiceRequest {
    #[must_use]
    pub fn from_body(body: &LndInvoiceRequestBody) -> Self {
        Self {
            form: body.to_string(),
        }
    }
    #[must_use]
    pub fn new(amount: u64) -> Self {
        let body = LndInvoiceRequestBody {
            value: amount,
            memo: None,
        };
        Self {
            form: body.to_string(),
        }
    }
}
impl std::fmt::Display for LndInvoiceRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", serde_json::to_string(self).unwrap_or_default())
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct LndInvoiceRequestBody {
    #[serde(serialize_with = "serialize_u64", deserialize_with = "deserialize_u64")]
    pub value: u64,
    pub memo: Option<String>,
}
#[allow(clippy::trivially_copy_pass_by_ref)]
fn serialize_u64<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    serializer.serialize_str(&value.to_string())
}
fn deserialize_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    s.parse::<u64>().map_err(serde::de::Error::custom)
}
impl std::fmt::Display for LndInvoiceRequestBody {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", serde_json::to_string(self).unwrap_or_default())
    }
}
impl LndInvoiceRequestBody {
    #[must_use]
    pub const fn new(value: u64, memo: Option<String>) -> Self {
        Self { value, memo }
    }
}