1use serde::{Deserialize, Serialize};
2use serde_with::{serde_as, DisplayFromStr};
3
4use crate::lsps0;
5
6#[derive(Debug, Serialize, Deserialize)]
7struct GetVersionsRequest {}
8
9#[derive(Debug, Serialize, Deserialize)]
10pub struct GetVersionsResponse {
11 pub versions: Vec<i32>,
12}
13
14#[derive(Debug, Serialize, Deserialize)]
15pub struct GetInfoRequest {
16 pub version: i32,
17
18 #[serde(skip_serializing_if = "Option::is_none")]
19 pub token: Option<String>,
20}
21
22#[serde_as]
23#[derive(Debug, Serialize, Deserialize, PartialEq)]
24pub struct GetInfoResponse {
25 pub opening_fee_params_menu: Vec<OpeningFeeParams>,
26
27 #[serde_as(as = "DisplayFromStr")]
28 pub min_payment_size_msat: u64,
29
30 #[serde_as(as = "DisplayFromStr")]
31 pub max_payment_size_msat: u64,
32}
33
34#[serde_as]
35#[derive(Debug, Serialize, Deserialize, PartialEq)]
36pub struct OpeningFeeParams {
37 #[serde_as(as = "DisplayFromStr")]
38 pub min_fee_msat: u64,
39 pub proportional: u32,
40 pub valid_until: String,
41 pub min_lifetime: u32,
42 pub max_client_to_self_delay: u32,
43 pub promise: String,
44}
45
46#[serde_as]
47#[derive(Debug, Serialize, Deserialize)]
48pub struct BuyRequest {
49 pub version: i32,
50 pub opening_fee_params: OpeningFeeParams,
51
52 #[serde(skip_serializing_if = "Option::is_none")]
53 #[serde_as(as = "Option<DisplayFromStr>")]
54 pub payment_size_msat: Option<u64>,
55}
56
57#[derive(Debug, Serialize, Deserialize, PartialEq)]
58pub struct BuyResponse {
59 pub jit_channel_scid: String,
60 pub lsp_cltv_expiry_delta: u32,
61
62 #[serde(default)]
63 pub client_trusts_lsp: bool,
64}
65
66#[derive(Debug, thiserror::Error)]
67pub enum GetInfoError {
68 #[error("lsps2.get_info unsupported_version error: {0:?}")]
69 UnsupportedVersion(lsps0::jsonrpc::RpcError),
70 #[error("lsps2.get_info unrecognized_or_stale_token error: {0:?}")]
71 UnrecognizedOrStaleToken(lsps0::jsonrpc::RpcError),
72 #[error("lsps2.get_info general error: {0}")]
73 Lsps0(lsps0::Error),
74}
75
76impl From<lsps0::Error> for GetInfoError {
77 fn from(value: lsps0::Error) -> Self {
78 match value {
79 lsps0::Error::Remote(e) => match e.code {
80 1 => Self::UnsupportedVersion(e),
81 2 => Self::UnrecognizedOrStaleToken(e),
82 _ => Self::Lsps0(lsps0::Error::Remote(e)),
83 },
84 _ => Self::Lsps0(value),
85 }
86 }
87}
88
89#[derive(Debug, thiserror::Error)]
90pub enum BuyError {
91 #[error("lsps2.buy unsupported_version error: {0:?}")]
92 UnsupportedVersion(lsps0::jsonrpc::RpcError),
93
94 #[error("lsps2.buy invalid_opening_fee_params error: {0:?}")]
95 InvalidOpeningFeeParams(lsps0::jsonrpc::RpcError),
96
97 #[error("lsps2.buy payment_size_too_small error: {0:?}")]
98 PaymentSizeTooSmall(lsps0::jsonrpc::RpcError),
99
100 #[error("lsps2.buy payment_size_too_large error: {0:?}")]
101 PaymentSizeTooLarge(lsps0::jsonrpc::RpcError),
102
103 #[error("lsps2.buy general error: {0}")]
104 Lsps0(lsps0::Error),
105}
106
107impl From<lsps0::Error> for BuyError {
108 fn from(value: lsps0::Error) -> Self {
109 match value {
110 lsps0::Error::Remote(e) => match e.code {
111 1 => Self::UnsupportedVersion(e),
112 2 => Self::InvalidOpeningFeeParams(e),
113 3 => Self::PaymentSizeTooSmall(e),
114 4 => Self::PaymentSizeTooLarge(e),
115 _ => Self::Lsps0(lsps0::Error::Remote(e)),
116 },
117 _ => Self::Lsps0(value),
118 }
119 }
120}
121pub struct Client {
122 client: lsps0::Client,
123}
124
125impl Client {
126 #[allow(dead_code)]
127 pub fn new(client: lsps0::Client) -> Self {
128 Self { client }
129 }
130
131 #[allow(dead_code)]
132 pub async fn get_versions(&self) -> Result<GetVersionsResponse, lsps0::Error> {
133 self.client
134 .call(String::from("lsps2.get_versions"), GetVersionsRequest {})
135 .await
136 }
137
138 #[allow(dead_code)]
139 pub async fn get_info(&self, req: GetInfoRequest) -> Result<GetInfoResponse, GetInfoError> {
140 match self.client.call(String::from("lsps2.get_info"), req).await {
141 Ok(v) => Ok(v),
142 Err(e) => Err(e.into()),
143 }
144 }
145
146 #[allow(dead_code)]
147 pub async fn buy(&self, req: BuyRequest) -> Result<BuyResponse, BuyError> {
148 match self.client.call(String::from("lsps2.buy"), req).await {
149 Ok(v) => Ok(v),
150 Err(e) => Err(e.into()),
151 }
152 }
153}
154
155#[cfg(test)]
156mod tests {
157 use crate::lsps2::client::{
158 BuyRequest, BuyResponse, GetInfoRequest, GetInfoResponse, GetVersionsResponse,
159 OpeningFeeParams,
160 };
161
162 #[test]
163 fn test_get_versions_response_deserialize() {
164 let json = r#"{"versions":[1]}"#;
165 let result = serde_json::from_str::<GetVersionsResponse>(json).unwrap();
166 assert_eq!(vec![1], result.versions)
167 }
168
169 #[test]
170 fn test_get_info_request_serialize_with_token() {
171 let req = GetInfoRequest {
172 token: Some(String::from("token")),
173 version: 1,
174 };
175 let result = serde_json::to_string(&req).unwrap();
176 assert_eq!(r#"{"version":1,"token":"token"}"#, result)
177 }
178
179 #[test]
180 fn test_get_info_request_serialize_without_token() {
181 let req = GetInfoRequest {
182 token: None,
183 version: 1,
184 };
185 let result = serde_json::to_string(&req).unwrap();
186 assert_eq!(r#"{"version":1}"#, result)
187 }
188
189 #[test]
190 fn test_get_info_response_deserialize() {
191 let json = r#"{
192 "opening_fee_params_menu": [
193 {
194 "min_fee_msat": "546000",
195 "proportional": 1200,
196 "valid_until": "2023-02-23T08:47:30.511Z",
197 "min_lifetime": 1008,
198 "max_client_to_self_delay": 2016,
199 "promise": "abcdefghijklmnopqrstuvwxyz"
200 },
201 {
202 "min_fee_msat": "1092000",
203 "proportional": 2400,
204 "valid_until": "2023-02-27T21:23:57.984Z",
205 "min_lifetime": 1008,
206 "max_client_to_self_delay": 2016,
207 "promise": "abcdefghijklmnopqrstuvwxyz"
208 }
209 ],
210 "min_payment_size_msat": "1000",
211 "max_payment_size_msat": "1000000"
212 }"#;
213
214 let result = serde_json::from_str::<GetInfoResponse>(json).unwrap();
215 assert_eq!(
216 result,
217 GetInfoResponse {
218 max_payment_size_msat: 1000000,
219 min_payment_size_msat: 1000,
220 opening_fee_params_menu: vec![
221 OpeningFeeParams {
222 min_fee_msat: 546000,
223 proportional: 1200,
224 valid_until: String::from("2023-02-23T08:47:30.511Z"),
225 min_lifetime: 1008,
226 max_client_to_self_delay: 2016,
227 promise: String::from("abcdefghijklmnopqrstuvwxyz")
228 },
229 OpeningFeeParams {
230 min_fee_msat: 1092000,
231 proportional: 2400,
232 valid_until: String::from("2023-02-27T21:23:57.984Z"),
233 min_lifetime: 1008,
234 max_client_to_self_delay: 2016,
235 promise: String::from("abcdefghijklmnopqrstuvwxyz")
236 },
237 ]
238 }
239 )
240 }
241
242 #[test]
243 fn test_buy_request_serialize_with_payment_size() {
244 let req = BuyRequest {
245 version: 1,
246 opening_fee_params: OpeningFeeParams {
247 min_fee_msat: 546000,
248 proportional: 1200,
249 valid_until: String::from("2023-02-23T08:47:30.511Z"),
250 min_lifetime: 1008,
251 max_client_to_self_delay: 2016,
252 promise: String::from("abcdefghijklmnopqrstuvwxyz"),
253 },
254 payment_size_msat: Some(42000),
255 };
256 let result = serde_json::to_string(&req).unwrap();
257 assert_eq!(
258 r#"{"version":1,"opening_fee_params":{"min_fee_msat":"546000","proportional":1200,"valid_until":"2023-02-23T08:47:30.511Z","min_lifetime":1008,"max_client_to_self_delay":2016,"promise":"abcdefghijklmnopqrstuvwxyz"},"payment_size_msat":"42000"}"#,
259 result
260 )
261 }
262
263 #[test]
264 fn test_buy_request_serialize_without_payment_size() {
265 let req = BuyRequest {
266 version: 1,
267 opening_fee_params: OpeningFeeParams {
268 min_fee_msat: 546000,
269 proportional: 1200,
270 valid_until: String::from("2023-02-23T08:47:30.511Z"),
271 min_lifetime: 1008,
272 max_client_to_self_delay: 2016,
273 promise: String::from("abcdefghijklmnopqrstuvwxyz"),
274 },
275 payment_size_msat: None,
276 };
277 let result = serde_json::to_string(&req).unwrap();
278 assert_eq!(
279 r#"{"version":1,"opening_fee_params":{"min_fee_msat":"546000","proportional":1200,"valid_until":"2023-02-23T08:47:30.511Z","min_lifetime":1008,"max_client_to_self_delay":2016,"promise":"abcdefghijklmnopqrstuvwxyz"}}"#,
280 result
281 )
282 }
283
284 #[test]
285 fn test_buy_response_deserialize_with_client_trusts_lsp_false() {
286 let json = r#"{
287 "jit_channel_scid": "1x4815x29451",
288 "lsp_cltv_expiry_delta" : 144,
289 "client_trusts_lsp": false
290 }"#;
291
292 let result = serde_json::from_str::<BuyResponse>(json).unwrap();
293 assert_eq!(
294 result,
295 BuyResponse {
296 client_trusts_lsp: false,
297 jit_channel_scid: String::from("1x4815x29451"),
298 lsp_cltv_expiry_delta: 144
299 }
300 );
301 }
302
303 #[test]
304 fn test_buy_response_deserialize_with_client_trusts_lsp_true() {
305 let json = r#"{
306 "jit_channel_scid": "1x4815x29451",
307 "lsp_cltv_expiry_delta" : 144,
308 "client_trusts_lsp": true
309 }"#;
310
311 let result = serde_json::from_str::<BuyResponse>(json).unwrap();
312 assert_eq!(
313 result,
314 BuyResponse {
315 client_trusts_lsp: true,
316 jit_channel_scid: String::from("1x4815x29451"),
317 lsp_cltv_expiry_delta: 144
318 }
319 );
320 }
321
322 #[test]
323 fn test_buy_response_deserialize_without_client_trusts_lsp() {
324 let json = r#"{
325 "jit_channel_scid": "1x4815x29451",
326 "lsp_cltv_expiry_delta": 144
327 }"#;
328
329 let result = serde_json::from_str::<BuyResponse>(json).unwrap();
330 assert_eq!(
331 result,
332 BuyResponse {
333 client_trusts_lsp: false,
334 jit_channel_scid: String::from("1x4815x29451"),
335 lsp_cltv_expiry_delta: 144
336 }
337 );
338 }
339}