Merge pull request #109 from tnull/2024-02-custom-serde-strings

De-/serialize all amount fields as JSON strings

Author: tnull

src/lsps0/mod.rs

@@ -12,4 +12,5 @@
 pub mod client;
 pub mod event;
 pub mod msgs;
+pub(crate) mod ser;
 pub mod service;

src/lsps0/ser.rs

@@ -0,0 +1,53 @@
+pub(crate) mod string_amount {
+	use crate::prelude::{String, ToString};
+	use core::str::FromStr;
+	use serde::de::Unexpected;
+	use serde::{Deserialize, Deserializer, Serializer};
+
+	pub(crate) fn serialize<S>(x: &u64, s: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		s.serialize_str(&x.to_string())
+	}
+
+	pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<u64, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let buf = String::deserialize(deserializer)?;
+
+		u64::from_str(&buf).map_err(|_| {
+			serde::de::Error::invalid_value(Unexpected::Str(&buf), &"invalid u64 amount string")
+		})
+	}
+}
+
+pub(crate) mod string_amount_option {
+	use crate::prelude::{String, ToString};
+	use core::str::FromStr;
+	use serde::de::Unexpected;
+	use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+	pub(crate) fn serialize<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let v = x.as_ref().map(|v| v.to_string());
+		Option::<String>::serialize(&v, s)
+	}
+
+	pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		if let Some(buf) = Option::<String>::deserialize(deserializer)? {
+			let val = u64::from_str(&buf).map_err(|_| {
+				serde::de::Error::invalid_value(Unexpected::Str(&buf), &"invalid u64 amount string")
+			})?;
+			Ok(Some(val))
+		} else {
+			Ok(None)
+		}
+	}
+}

src/lsps1/msgs.rs

@@ -1,6 +1,8 @@
 //! Message, request, and other primitive types used to implement LSPS1.
 
 use crate::lsps0::msgs::{LSPSMessage, RequestId, ResponseError};
+use crate::lsps0::ser::{string_amount, string_amount_option};
+
 use crate::prelude::{String, Vec};
 
 use serde::{Deserialize, Serialize};
@@ -41,20 +43,27 @@ pub struct OptionsSupported {
 	pub supports_zero_channel_reserve: bool,
 	/// Indicates the minimum amount of satoshi that is required for the LSP to accept a payment
 	/// on-chain.
-	pub min_onchain_payment_size_sat: Option<u32>,
+	#[serde(with = "string_amount_option")]
+	pub min_onchain_payment_size_sat: Option<u64>,
 	/// The maximum number of blocks a channel can be leased for.
 	pub max_channel_expiry_blocks: u32,
 	/// The minimum number of satoshi that the client MUST request.
+	#[serde(with = "string_amount")]
 	pub min_initial_client_balance_sat: u64,
 	/// The maximum number of satoshi that the client MUST request.
+	#[serde(with = "string_amount")]
 	pub max_initial_client_balance_sat: u64,
 	/// The minimum number of satoshi that the LSP will provide to the channel.
+	#[serde(with = "string_amount")]
 	pub min_initial_lsp_balance_sat: u64,
 	/// The maximum number of satoshi that the LSP will provide to the channel.
+	#[serde(with = "string_amount")]
 	pub max_initial_lsp_balance_sat: u64,
 	/// The minimal channel size.
+	#[serde(with = "string_amount")]
 	pub min_channel_balance_sat: u64,
 	/// The maximal channel size.
+	#[serde(with = "string_amount")]
 	pub max_channel_balance_sat: u64,
 }
 
@@ -81,11 +90,13 @@ pub struct CreateOrderRequest {
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct OrderParams {
 	/// Indicates how many satoshi the LSP will provide on their side.
+	#[serde(with = "string_amount")]
 	pub lsp_balance_sat: u64,
 	/// Indicates how many satoshi the client will provide on their side.
 	///
 	/// The client sends these funds to the LSP, who will push them back to the client upon opening
 	/// the channel.
+	#[serde(with = "string_amount")]
 	pub client_balance_sat: u64,
 	/// The number of blocks the client wants to wait maximally for the channel to be confirmed.
 	pub confirms_within_blocks: u32,
@@ -135,8 +146,10 @@ pub struct OrderPayment {
 	/// Indicates the current state of the payment.
 	pub state: PaymentState,
 	/// The total fee the LSP will charge to open this channel in satoshi.
+	#[serde(with = "string_amount")]
 	pub fee_total_sat: u64,
 	/// What the client needs to pay in total to open the requested channel.
+	#[serde(with = "string_amount")]
 	pub order_total_sat: u64,
 	/// A BOLT11 invoice the client can pay to have to channel opened.
 	pub bolt11_invoice: String,
@@ -172,6 +185,7 @@ pub struct OnchainPayment {
 	/// The outpoint of the payment.
 	pub outpoint: String,
 	/// The amount of satoshi paid.
+	#[serde(with = "string_amount")]
 	pub sat: u64,
 	/// Indicates if the LSP regards the transaction as sufficiently confirmed.
 	pub confirmed: bool,
@@ -287,3 +301,42 @@ impl From<LSPS1Message> for LSPSMessage {
 		LSPSMessage::LSPS1(message)
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::alloc::string::ToString;
+
+	#[test]
+	fn options_supported_serialization() {
+		let min_channel_confirmations = 6;
+		let min_onchain_payment_confirmations = Some(6);
+		let supports_zero_channel_reserve = true;
+		let min_onchain_payment_size_sat = Some(100_000);
+		let max_channel_expiry_blocks = 144;
+		let min_initial_client_balance_sat = 10_000_000;
+		let max_initial_client_balance_sat = 100_000_000;
+		let min_initial_lsp_balance_sat = 100_000;
+		let max_initial_lsp_balance_sat = 100_000_000;
+		let min_channel_balance_sat = 100_000;
+		let max_channel_balance_sat = 100_000_000;
+
+		let options_supported = OptionsSupported {
+			min_channel_confirmations,
+			min_onchain_payment_confirmations,
+			supports_zero_channel_reserve,
+			min_onchain_payment_size_sat,
+			max_channel_expiry_blocks,
+			min_initial_client_balance_sat,
+			max_initial_client_balance_sat,
+			min_initial_lsp_balance_sat,
+			max_initial_lsp_balance_sat,
+			min_channel_balance_sat,
+			max_channel_balance_sat,
+		};
+
+		let json_str = r#"{"max_channel_balance_sat":"100000000","max_channel_expiry_blocks":144,"max_initial_client_balance_sat":"100000000","max_initial_lsp_balance_sat":"100000000","min_channel_balance_sat":"100000","min_channel_confirmations":6,"min_initial_client_balance_sat":"10000000","min_initial_lsp_balance_sat":"100000","min_onchain_payment_confirmations":6,"min_onchain_payment_size_sat":"100000","supports_zero_channel_reserve":true}"#;
+		assert_eq!(json_str, serde_json::json!(options_supported).to_string());
+		assert_eq!(options_supported, serde_json::from_str(json_str).unwrap());
+	}
+}

src/lsps2/msgs.rs

@@ -9,6 +9,7 @@ use chrono::Utc;
 use serde::{Deserialize, Serialize};
 
 use crate::lsps0::msgs::{LSPSMessage, RequestId, ResponseError};
+use crate::lsps0::ser::{string_amount, string_amount_option};
 use crate::prelude::{String, Vec};
 use crate::utils;
 
@@ -82,6 +83,7 @@ impl RawOpeningFeeParams {
 /// the promise using the secret. Once verified they can be confident it was not modified by the client.
 pub struct OpeningFeeParams {
 	/// The minimum fee required for the channel open.
+	#[serde(with = "string_amount")]
 	pub min_fee_msat: u64,
 	/// A fee proportional to the size of the initial payment.
 	pub proportional: u32,
@@ -92,8 +94,10 @@ pub struct OpeningFeeParams {
 	/// The maximum number of blocks that the client is allowed to set its `to_self_delay` parameter.
 	pub max_client_to_self_delay: u32,
 	/// The minimum payment size that the LSP will accept when opening a channel.
+	#[serde(with = "string_amount")]
 	pub min_payment_size_msat: u64,
 	/// The maximum payment size that the LSP will accept when opening a channel.
+	#[serde(with = "string_amount")]
 	pub max_payment_size_msat: u64,
 	/// The HMAC used to verify the authenticity of these parameters.
 	pub promise: String,
@@ -112,7 +116,9 @@ pub struct BuyRequest {
 	/// The fee parameters you would like to use.
 	pub opening_fee_params: OpeningFeeParams,
 	/// The size of the initial payment you expect to receive.
+	#[serde(default)]
 	#[serde(skip_serializing_if = "Option::is_none")]
+	#[serde(with = "string_amount_option")]
 	pub payment_size_msat: Option<u64>,
 }
 
@@ -213,6 +219,7 @@ impl From<LSPS2Message> for LSPSMessage {
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use crate::alloc::string::ToString;
 	use crate::lsps2::utils::is_valid_opening_fee_params;
 
 	#[test]
@@ -330,4 +337,51 @@ mod tests {
 		let opening_fee_params = raw.into_opening_fee_params(&promise_secret);
 		assert!(!is_valid_opening_fee_params(&opening_fee_params, &promise_secret));
 	}
+
+	#[test]
+	fn buy_request_serialization() {
+		let min_fee_msat = 100;
+		let proportional = 21;
+		let valid_until = chrono::DateTime::parse_from_rfc3339("2023-05-20T08:30:45Z").unwrap();
+		let min_lifetime = 144;
+		let max_client_to_self_delay = 128;
+		let min_payment_size_msat = 1;
+		let max_payment_size_msat = 100_000_000;
+
+		let raw = RawOpeningFeeParams {
+			min_fee_msat,
+			proportional,
+			valid_until: valid_until.into(),
+			min_lifetime,
+			max_client_to_self_delay,
+			min_payment_size_msat,
+			max_payment_size_msat,
+		};
+
+		let promise_secret = [1u8; 32];
+
+		let opening_fee_params = raw.into_opening_fee_params(&promise_secret);
+		let json_str = r#"{"max_client_to_self_delay":128,"max_payment_size_msat":"100000000","min_fee_msat":"100","min_lifetime":144,"min_payment_size_msat":"1","promise":"1134a5c51e3ba2e8f4259610d5e12c1bf4c50ddcd3f8af563e0a00d1fff41dea","proportional":21,"valid_until":"2023-05-20T08:30:45Z"}"#;
+		assert_eq!(json_str, serde_json::json!(opening_fee_params).to_string());
+		assert_eq!(opening_fee_params, serde_json::from_str(json_str).unwrap());
+
+		let payment_size_msat = Some(1234);
+		let buy_request_fixed =
+			BuyRequest { opening_fee_params: opening_fee_params.clone(), payment_size_msat };
+		let json_str = r#"{"opening_fee_params":{"max_client_to_self_delay":128,"max_payment_size_msat":"100000000","min_fee_msat":"100","min_lifetime":144,"min_payment_size_msat":"1","promise":"1134a5c51e3ba2e8f4259610d5e12c1bf4c50ddcd3f8af563e0a00d1fff41dea","proportional":21,"valid_until":"2023-05-20T08:30:45Z"},"payment_size_msat":"1234"}"#;
+		assert_eq!(json_str, serde_json::json!(buy_request_fixed).to_string());
+		assert_eq!(buy_request_fixed, serde_json::from_str(json_str).unwrap());
+
+		let payment_size_msat = None;
+		let buy_request_variable = BuyRequest { opening_fee_params, payment_size_msat };
+
+		// Check we skip serialization if payment_size_msat is None.
+		let json_str = r#"{"opening_fee_params":{"max_client_to_self_delay":128,"max_payment_size_msat":"100000000","min_fee_msat":"100","min_lifetime":144,"min_payment_size_msat":"1","promise":"1134a5c51e3ba2e8f4259610d5e12c1bf4c50ddcd3f8af563e0a00d1fff41dea","proportional":21,"valid_until":"2023-05-20T08:30:45Z"}}"#;
+		assert_eq!(json_str, serde_json::json!(buy_request_variable).to_string());
+		assert_eq!(buy_request_variable, serde_json::from_str(json_str).unwrap());
+
+		// Check we still deserialize correctly if payment_size_msat is 'null'.
+		let json_str = r#"{"opening_fee_params":{"max_client_to_self_delay":128,"max_payment_size_msat":"100000000","min_fee_msat":"100","min_lifetime":144,"min_payment_size_msat":"1","promise":"1134a5c51e3ba2e8f4259610d5e12c1bf4c50ddcd3f8af563e0a00d1fff41dea","proportional":21,"valid_until":"2023-05-20T08:30:45Z"},"payment_size_msat":null}"#;
+		assert_eq!(buy_request_variable, serde_json::from_str(json_str).unwrap());
+	}
 }