lnm-sdk 0.4.2

Rust SDK for interacting with LN Markets.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::sync::Arc;

use crate::shared::rest::{
    error::Result,
    lnm::{base::LnmRestBase, rate_limit::RateLimiter},
};

pub(super) mod config;
pub(crate) mod error;
mod lnm;
pub(super) mod models;
pub(super) mod repositories;

use config::RestClientConfig;
use lnm::{
    futures::LnmFuturesRepository, signature::SignatureGeneratorV2, user::LnmUserRepository,
};
use repositories::{FuturesRepository, UserRepository};

/// Client for interacting with the [LNM's v2 API] via REST.
///
/// When credentials are provided, it supports authenticated endpoints.
///
/// [LNM's v2 API]: https://docs.lnmarkets.com/api/#overview
#[deprecated(
    since = "0.1.0",
    note = "LN Markets disabled the v2 REST API on Mar 31 2026. Retained for reference only. Use `lnm_sdk::api_v3::RestClient` instead."
)]
pub struct RestClient {
    /// Will be `true` if LNM credentials were provided, and `false` otherwise.
    /// See [`RestClient::with_credentials`].
    pub has_credentials: bool,

    /// Methods for interacting with [LNM's v2 API]'s REST Futures endpoints.
    ///
    /// [LNM's v2 API]: https://docs.lnmarkets.com/api/#overview
    pub futures: Box<dyn FuturesRepository>,

    /// Methods for interacting with [LNM's v2 API]'s REST User endpoints.
    ///
    /// [LNM's v2 API]: https://docs.lnmarkets.com/api/#overview
    pub user: Box<dyn UserRepository>,
}

#[allow(deprecated)]
impl RestClient {
    fn new_inner(base: Arc<LnmRestBase<SignatureGeneratorV2>>) -> Arc<Self> {
        let has_credentials = base.has_credentials();
        let futures = Box::new(LnmFuturesRepository::new(base.clone()));
        let user = Box::new(LnmUserRepository::new(base));

        Arc::new(Self {
            has_credentials,
            futures,
            user,
        })
    }

    /// Creates a new unauthenticated REST client.
    ///
    /// For authenticated endpoints, use [`RestClient::with_credentials`].
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # #[allow(deprecated)]
    /// # fn example() -> Result<(), Box<dyn std::error::Error>> {
    /// use std::env;
    /// use lnm_sdk::api_v2::{RestClient, RestClientConfig};
    ///
    /// let domain = env::var("LNM_API_DOMAIN").unwrap();
    ///
    /// let client = RestClient::new(RestClientConfig::default(), domain)?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new(config: impl Into<RestClientConfig>, domain: impl ToString) -> Result<Arc<Self>> {
        let config = config.into();
        let rate_limiter = config
            .rate_limiter_active()
            .then(|| RateLimiter::from(&config));
        let base = LnmRestBase::new(config.timeout(), domain.to_string(), rate_limiter)?;

        Ok(Self::new_inner(base))
    }

    /// Creates a new authenticated REST client with credentials.
    ///
    /// If not accessing authenticated endpoints, consider using [`RestClient::new`].
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # #[allow(deprecated)]
    /// # fn example() -> Result<(), Box<dyn std::error::Error>> {
    /// use std::env;
    /// use lnm_sdk::api_v2::{RestClient, RestClientConfig};
    ///
    /// let domain = env::var("LNM_API_DOMAIN").unwrap();
    /// let key = env::var("LNM_API_KEY").unwrap();
    /// let secret = env::var("LNM_API_SECRET").unwrap();
    /// let pphrase = env::var("LNM_API_PASSPHRASE").unwrap();
    ///
    /// let config = RestClientConfig::default();
    /// let client = RestClient::with_credentials(config, domain, key, secret, pphrase)?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn with_credentials(
        config: impl Into<RestClientConfig>,
        domain: impl ToString,
        key: impl ToString,
        secret: impl ToString,
        passphrase: impl ToString,
    ) -> Result<Arc<Self>> {
        let config = config.into();
        let rate_limiter = config
            .rate_limiter_active()
            .then(|| RateLimiter::from(&config));
        let base = LnmRestBase::with_credentials(
            config.timeout(),
            domain.to_string(),
            key.to_string(),
            passphrase.to_string(),
            SignatureGeneratorV2::new(secret.to_string()),
            rate_limiter,
        )?;

        Ok(Self::new_inner(base))
    }
}