Skip to main content

electrum_client/
raw_client.rs

1// SPDX-License-Identifier: MIT OR Apache-2.0
2
3//! Raw client
4//!
5//! This module contains the definition of the raw client that wraps the transport method
6
7use std::borrow::Borrow;
8use std::collections::{BTreeMap, HashMap, VecDeque};
9use std::io::{BufRead, BufReader, Read, Write};
10use std::mem::drop;
11use std::net::{TcpStream, ToSocketAddrs};
12use std::sync::atomic::{AtomicUsize, Ordering};
13use std::sync::mpsc::{channel, Receiver, Sender};
14use std::sync::{Arc, Mutex, TryLockError};
15use std::time::Duration;
16
17#[allow(unused_imports)]
18use log::{debug, error, info, trace, warn};
19
20use bitcoin::consensus::encode::deserialize;
21use bitcoin::hex::{DisplayHex, FromHex};
22use bitcoin::{Script, Txid};
23
24#[cfg(feature = "openssl")]
25use openssl::ssl::{SslConnector, SslMethod, SslStream, SslVerifyMode};
26
27#[cfg(any(feature = "rustls", feature = "rustls-ring"))]
28#[allow(unused_imports)]
29use rustls::{pki_types::ServerName, ClientConfig, ClientConnection, RootCertStore, StreamOwned};
30
31#[cfg(feature = "proxy")]
32use crate::socks::{Socks5Stream, TargetAddr, ToTargetAddr};
33
34use crate::stream::ClonableStream;
35
36use crate::api::ElectrumApi;
37use crate::batch::Batch;
38use crate::config::AuthProvider;
39use crate::types::*;
40
41/// Client name sent to the server during protocol version negotiation.
42pub const CLIENT_NAME: &str = "";
43
44/// Minimum protocol version supported by this client.
45pub const PROTOCOL_VERSION_MIN: &str = "1.4";
46
47/// Maximum protocol version supported by this client.
48pub const PROTOCOL_VERSION_MAX: &str = "1.6";
49
50/// Checks if a protocol version string is at least the specified major.minor version.
51fn is_protocol_version_at_least(version: &str, major: u32, minor: u32) -> bool {
52    let mut parts = version.split('.');
53    let v_major = parts.next().and_then(|s| s.parse::<u32>().ok());
54    let v_minor = parts.next().and_then(|s| s.parse::<u32>().ok());
55    match (v_major, v_minor) {
56        (Some(v_major), Some(v_minor)) => v_major > major || (v_major == major && v_minor >= minor),
57        _ => false,
58    }
59}
60
61macro_rules! impl_batch_call {
62    ( $self:expr, $data:expr, $call:ident ) => {{
63        impl_batch_call!($self, $data, $call, )
64    }};
65
66    ( $self:expr, $data:expr, $call:ident, apply_deref ) => {{
67        impl_batch_call!($self, $data, $call, *)
68    }};
69
70    ( $self:expr, $data:expr, $call:ident, $($apply_deref:tt)? ) => {{
71        let mut batch = Batch::default();
72        for i in $data {
73            batch.$call($($apply_deref)* i.borrow());
74        }
75
76        let resp = $self.batch_call(&batch)?;
77        let mut answer = Vec::new();
78
79        for x in resp {
80            answer.push(serde_json::from_value(x)?);
81        }
82
83        Ok(answer)
84    }};
85}
86
87/// A trait for [`ToSocketAddrs`](https://doc.rust-lang.org/std/net/trait.ToSocketAddrs.html) that
88/// can also be turned into a domain. Used when an SSL client needs to validate the server's
89/// certificate.
90pub trait ToSocketAddrsDomain: ToSocketAddrs {
91    /// Returns the domain, if present
92    fn domain(&self) -> Option<&str> {
93        None
94    }
95}
96
97impl ToSocketAddrsDomain for &str {
98    fn domain(&self) -> Option<&str> {
99        self.split(':').next()
100    }
101}
102
103impl ToSocketAddrsDomain for (&str, u16) {
104    fn domain(&self) -> Option<&str> {
105        self.0.domain()
106    }
107}
108
109#[cfg(feature = "proxy")]
110impl ToSocketAddrsDomain for TargetAddr {
111    fn domain(&self) -> Option<&str> {
112        match self {
113            TargetAddr::Ip(_) => None,
114            TargetAddr::Domain(domain, _) => Some(domain.as_str()),
115        }
116    }
117}
118
119macro_rules! impl_to_socket_addrs_domain {
120    ( $ty:ty ) => {
121        impl ToSocketAddrsDomain for $ty {}
122    };
123}
124
125impl_to_socket_addrs_domain!(std::net::SocketAddr);
126impl_to_socket_addrs_domain!(std::net::SocketAddrV4);
127impl_to_socket_addrs_domain!(std::net::SocketAddrV6);
128impl_to_socket_addrs_domain!((std::net::IpAddr, u16));
129impl_to_socket_addrs_domain!((std::net::Ipv4Addr, u16));
130impl_to_socket_addrs_domain!((std::net::Ipv6Addr, u16));
131
132/// Instance of an Electrum client
133///
134/// A [`RawClient`] maintains a constant connection with an Electrum server and exposes methods to
135/// interact with it. It can also subscribe and receive notifications from the server about new
136/// blocks or activity on a specific *scriptPubKey*.
137///
138/// The [`RawClient`] is modeled in such a way that allows the external caller to have full control over
139/// its functionality: no threads or tasks are spawned internally to monitor the state of the
140/// connection.
141///
142/// More transport methods can be used by manually creating an instance of this struct with an
143/// arbitrary `S` type.
144pub struct RawClient<S>
145where
146    S: Read + Write,
147{
148    stream: Mutex<ClonableStream<S>>,
149    buf_reader: Mutex<BufReader<ClonableStream<S>>>,
150
151    last_id: AtomicUsize,
152    waiting_map: Mutex<HashMap<usize, Sender<ChannelMessage>>>,
153
154    headers: Mutex<VecDeque<RawHeaderNotification>>,
155    script_notifications: Mutex<HashMap<ScriptHash, VecDeque<ScriptStatus>>>,
156
157    /// The protocol version negotiated with the server via `server.version`.
158    protocol_version: Mutex<Option<String>>,
159
160    /// Optional authorization provider for dynamic token injection (e.g., JWT).
161    auth_provider: Option<AuthProvider>,
162
163    calls: AtomicUsize,
164}
165
166// Custom Debug impl because AuthProvider doesn't implement Debug
167impl<S> std::fmt::Debug for RawClient<S>
168where
169    S: Read + Write,
170{
171    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
172        f.debug_struct("RawClient")
173            .field("stream", &"<stream>")
174            .field("buf_reader", &"<buf_reader>")
175            .field("last_id", &self.last_id)
176            .field("waiting_map", &self.waiting_map)
177            .field("headers", &self.headers)
178            .field("script_notifications", &self.script_notifications)
179            .field(
180                "auth_provider",
181                &self.auth_provider.as_ref().map(|_| "<provider>"),
182            )
183            .finish()
184    }
185}
186
187impl<S> From<S> for RawClient<S>
188where
189    S: Read + Write,
190{
191    fn from(stream: S) -> Self {
192        let stream: ClonableStream<_> = stream.into();
193
194        Self {
195            buf_reader: Mutex::new(BufReader::new(stream.clone())),
196            stream: Mutex::new(stream),
197
198            last_id: AtomicUsize::new(0),
199            waiting_map: Mutex::new(HashMap::new()),
200
201            headers: Mutex::new(VecDeque::new()),
202            script_notifications: Mutex::new(HashMap::new()),
203
204            protocol_version: Mutex::new(None),
205
206            auth_provider: None,
207
208            calls: AtomicUsize::new(0),
209        }
210    }
211}
212
213/// Transport type used to establish a plaintext TCP connection with the server
214pub type ElectrumPlaintextStream = TcpStream;
215impl RawClient<ElectrumPlaintextStream> {
216    /// Creates a new plaintext client and tries to connect to `socket_addr`.
217    ///
218    /// Automatically negotiates the protocol version with the server using
219    /// `server.version` as required by the Electrum protocol.
220    pub fn new<A: ToSocketAddrs>(
221        socket_addrs: A,
222        timeout: Option<Duration>,
223        auth_provider: Option<AuthProvider>,
224    ) -> Result<Self, Error> {
225        let stream = match timeout {
226            Some(timeout) => {
227                let stream = connect_with_total_timeout(socket_addrs, timeout)?;
228                stream.set_read_timeout(Some(timeout))?;
229                stream.set_write_timeout(Some(timeout))?;
230                stream
231            }
232            None => TcpStream::connect(socket_addrs)?,
233        };
234
235        let client = Self::from(stream)
236            .with_auth(auth_provider)
237            .negotiate_protocol_version()?;
238
239        Ok(client)
240    }
241}
242
243fn connect_with_total_timeout<A: ToSocketAddrs>(
244    socket_addrs: A,
245    mut timeout: Duration,
246) -> Result<TcpStream, Error> {
247    // Use the same algorithm as curl: 1/2 on the first host, 1/4 on the second one, etc.
248    // https://curl.se/mail/lib-2014-11/0164.html
249
250    let mut errors = Vec::new();
251
252    let addrs = socket_addrs
253        .to_socket_addrs()?
254        .enumerate()
255        .collect::<Vec<_>>();
256    for (index, addr) in &addrs {
257        if *index < addrs.len() - 1 {
258            timeout = timeout.div_f32(2.0);
259        }
260
261        info!(
262            "Trying to connect to {} (attempt {}/{}) with timeout {:?}",
263            addr,
264            index + 1,
265            addrs.len(),
266            timeout
267        );
268        match TcpStream::connect_timeout(addr, timeout) {
269            Ok(socket) => return Ok(socket),
270            Err(e) => {
271                warn!("Connection error: {:?}", e);
272                errors.push(e.into());
273            }
274        }
275    }
276
277    Err(Error::AllAttemptsErrored(errors))
278}
279
280#[cfg(feature = "openssl")]
281/// Transport type used to establish an OpenSSL TLS encrypted/authenticated connection with the server
282pub type ElectrumSslStream = SslStream<TcpStream>;
283#[cfg(feature = "openssl")]
284impl RawClient<ElectrumSslStream> {
285    /// Creates a new SSL client and tries to connect to `socket_addr`. Optionally, if
286    /// `validate_domain` is `true`, validate the server's certificate.
287    pub fn new_ssl<A: ToSocketAddrsDomain + Clone>(
288        socket_addrs: A,
289        validate_domain: bool,
290        timeout: Option<Duration>,
291        auth_provider: Option<AuthProvider>,
292    ) -> Result<Self, Error> {
293        debug!(
294            "new_ssl socket_addrs.domain():{:?} validate_domain:{} timeout:{:?}",
295            socket_addrs.domain(),
296            validate_domain,
297            timeout
298        );
299        if validate_domain {
300            socket_addrs.domain().ok_or(Error::MissingDomain)?;
301        }
302        match timeout {
303            Some(timeout) => {
304                let stream = connect_with_total_timeout(socket_addrs.clone(), timeout)?;
305                stream.set_read_timeout(Some(timeout))?;
306                stream.set_write_timeout(Some(timeout))?;
307                Self::new_ssl_from_stream(socket_addrs, validate_domain, stream, auth_provider)
308            }
309            None => {
310                let stream = TcpStream::connect(socket_addrs.clone())?;
311                Self::new_ssl_from_stream(socket_addrs, validate_domain, stream, auth_provider)
312            }
313        }
314    }
315
316    /// Create a new SSL client using an existing TcpStream
317    pub fn new_ssl_from_stream<A: ToSocketAddrsDomain>(
318        socket_addrs: A,
319        validate_domain: bool,
320        stream: TcpStream,
321        auth_provider: Option<AuthProvider>,
322    ) -> Result<Self, Error> {
323        let mut builder =
324            SslConnector::builder(SslMethod::tls()).map_err(Error::InvalidSslMethod)?;
325
326        // TODO: support for certificate pinning
327        if validate_domain {
328            socket_addrs.domain().ok_or(Error::MissingDomain)?;
329        } else {
330            builder.set_verify(SslVerifyMode::NONE);
331        }
332        let connector = builder.build();
333
334        let domain = socket_addrs.domain().unwrap_or("NONE").to_string();
335
336        let stream = connector
337            .connect(&domain, stream)
338            .map_err(Error::SslHandshakeError)?;
339
340        let client = Self::from(stream)
341            .with_auth(auth_provider)
342            .negotiate_protocol_version()?;
343
344        Ok(client)
345    }
346}
347
348#[cfg(any(feature = "rustls", feature = "rustls-ring"))]
349#[allow(unused)]
350mod danger {
351    use crate::raw_client::ServerName;
352    use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified};
353    use rustls::crypto::CryptoProvider;
354    use rustls::pki_types::{CertificateDer, UnixTime};
355    use rustls::DigitallySignedStruct;
356
357    #[derive(Debug)]
358    pub struct NoCertificateVerification(CryptoProvider);
359
360    impl NoCertificateVerification {
361        pub fn new(provider: CryptoProvider) -> Self {
362            Self(provider)
363        }
364    }
365
366    impl rustls::client::danger::ServerCertVerifier for NoCertificateVerification {
367        fn verify_server_cert(
368            &self,
369            _end_entity: &CertificateDer<'_>,
370            _intermediates: &[CertificateDer<'_>],
371            _server_name: &ServerName<'_>,
372            _ocsp: &[u8],
373            _now: UnixTime,
374        ) -> Result<ServerCertVerified, rustls::Error> {
375            Ok(ServerCertVerified::assertion())
376        }
377
378        fn verify_tls12_signature(
379            &self,
380            _message: &[u8],
381            _cert: &CertificateDer<'_>,
382            _dss: &DigitallySignedStruct,
383        ) -> Result<HandshakeSignatureValid, rustls::Error> {
384            Ok(HandshakeSignatureValid::assertion())
385        }
386
387        fn verify_tls13_signature(
388            &self,
389            _message: &[u8],
390            _cert: &CertificateDer<'_>,
391            _dss: &DigitallySignedStruct,
392        ) -> Result<HandshakeSignatureValid, rustls::Error> {
393            Ok(HandshakeSignatureValid::assertion())
394        }
395
396        fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
397            self.0.signature_verification_algorithms.supported_schemes()
398        }
399    }
400}
401
402#[cfg(all(
403    any(feature = "rustls", feature = "rustls-ring"),
404    not(feature = "openssl")
405))]
406/// Transport type used to establish a Rustls TLS encrypted/authenticated connection with the server
407pub type ElectrumSslStream = StreamOwned<ClientConnection, TcpStream>;
408#[cfg(all(
409    any(feature = "rustls", feature = "rustls-ring"),
410    not(feature = "openssl")
411))]
412impl RawClient<ElectrumSslStream> {
413    /// Creates a new SSL client and tries to connect to `socket_addr`. Optionally, if
414    /// `validate_domain` is `true`, validate the server's certificate.
415    pub fn new_ssl<A: ToSocketAddrsDomain + Clone>(
416        socket_addrs: A,
417        validate_domain: bool,
418        timeout: Option<Duration>,
419        auth_provider: Option<AuthProvider>,
420    ) -> Result<Self, Error> {
421        debug!(
422            "new_ssl socket_addrs.domain():{:?} validate_domain:{} timeout:{:?}",
423            socket_addrs.domain(),
424            validate_domain,
425            timeout
426        );
427
428        if validate_domain {
429            socket_addrs.domain().ok_or(Error::MissingDomain)?;
430        }
431
432        match timeout {
433            Some(timeout) => {
434                let stream = connect_with_total_timeout(socket_addrs.clone(), timeout)?;
435                stream.set_read_timeout(Some(timeout))?;
436                stream.set_write_timeout(Some(timeout))?;
437                Self::new_ssl_from_stream(socket_addrs, validate_domain, stream, auth_provider)
438            }
439            None => {
440                let stream = TcpStream::connect(socket_addrs.clone())?;
441                Self::new_ssl_from_stream(socket_addrs, validate_domain, stream, auth_provider)
442            }
443        }
444    }
445
446    /// Create a new SSL client using an existing TcpStream
447    pub fn new_ssl_from_stream<A: ToSocketAddrsDomain>(
448        socket_addr: A,
449        validate_domain: bool,
450        tcp_stream: TcpStream,
451        auth_provider: Option<AuthProvider>,
452    ) -> Result<Self, Error> {
453        use std::convert::TryFrom;
454
455        if rustls::crypto::CryptoProvider::get_default().is_none() {
456            // We install a crypto provider depending on the set feature.
457            #[cfg(all(feature = "rustls", not(feature = "rustls-ring")))]
458            rustls::crypto::CryptoProvider::install_default(
459                rustls::crypto::aws_lc_rs::default_provider(),
460            )
461            .or_else(|_| {
462                rustls::crypto::CryptoProvider::get_default()
463                    .map(|_| ())
464                    .ok_or_else(|| {
465                        Error::CouldNotCreateConnection(rustls::Error::General(
466                            "Failed to install CryptoProvider".to_string(),
467                        ))
468                    })
469            })?;
470
471            #[cfg(feature = "rustls-ring")]
472            rustls::crypto::CryptoProvider::install_default(
473                rustls::crypto::ring::default_provider(),
474            )
475            .or_else(|_| {
476                rustls::crypto::CryptoProvider::get_default()
477                    .map(|_| ())
478                    .ok_or_else(|| {
479                        Error::CouldNotCreateConnection(rustls::Error::General(
480                            "Failed to install CryptoProvider".to_string(),
481                        ))
482                    })
483            })?;
484        }
485
486        let builder = ClientConfig::builder();
487
488        let config = if validate_domain {
489            socket_addr.domain().ok_or(Error::MissingDomain)?;
490
491            let store = RootCertStore {
492                roots: webpki_roots::TLS_SERVER_ROOTS.to_vec(),
493            };
494
495            // TODO: cert pinning
496            builder.with_root_certificates(store).with_no_client_auth()
497        } else {
498            builder
499                .dangerous()
500                .with_custom_certificate_verifier(std::sync::Arc::new(
501                    #[cfg(all(feature = "rustls", not(feature = "rustls-ring")))]
502                    danger::NoCertificateVerification::new(rustls::crypto::aws_lc_rs::default_provider()),
503                    #[cfg(feature = "rustls-ring")]
504                    danger::NoCertificateVerification::new(rustls::crypto::ring::default_provider()),
505                ))
506                .with_no_client_auth()
507        };
508
509        let domain = socket_addr.domain().unwrap_or("NONE").to_string();
510        let session = ClientConnection::new(
511            std::sync::Arc::new(config),
512            ServerName::try_from(domain.clone())
513                .map_err(|_| Error::InvalidDNSNameError(domain.clone()))?,
514        )
515        .map_err(Error::CouldNotCreateConnection)?;
516        let stream = StreamOwned::new(session, tcp_stream);
517
518        let client = Self::from(stream)
519            .with_auth(auth_provider)
520            .negotiate_protocol_version()?;
521
522        Ok(client)
523    }
524}
525
526#[cfg(feature = "proxy")]
527/// Transport type used to establish a connection to a server through a socks proxy
528pub type ElectrumProxyStream = Socks5Stream;
529#[cfg(feature = "proxy")]
530impl RawClient<ElectrumProxyStream> {
531    /// Creates a new socks client and tries to connect to `target_addr` using `proxy_addr` as a
532    /// socks proxy server. The DNS resolution of `target_addr`, if required, is done
533    /// through the proxy. This allows to specify, for instance, `.onion` addresses.
534    pub fn new_proxy<T: ToTargetAddr>(
535        target_addr: T,
536        proxy: &crate::Socks5Config,
537        timeout: Option<Duration>,
538        auth_provider: Option<AuthProvider>,
539    ) -> Result<Self, Error> {
540        let mut stream = match proxy.credentials.as_ref() {
541            Some(cred) => Socks5Stream::connect_with_password(
542                &proxy.addr,
543                target_addr,
544                &cred.username,
545                &cred.password,
546                timeout,
547            )?,
548            None => Socks5Stream::connect(&proxy.addr, target_addr, timeout)?,
549        };
550        stream.get_mut().set_read_timeout(timeout)?;
551        stream.get_mut().set_write_timeout(timeout)?;
552
553        let client = Self::from(stream)
554            .with_auth(auth_provider)
555            .negotiate_protocol_version()?;
556
557        Ok(client)
558    }
559
560    #[cfg(all(
561        any(feature = "openssl", feature = "rustls", feature = "rustls-ring",),
562        feature = "proxy",
563    ))]
564    /// Creates a new TLS client that connects to `target_addr` using `proxy_addr` as a socks proxy
565    /// server. The DNS resolution of `target_addr`, if required, is done through the proxy. This
566    /// allows to specify, for instance, `.onion` addresses.
567    pub fn new_proxy_ssl<T: ToTargetAddr>(
568        target_addr: T,
569        validate_domain: bool,
570        proxy: &crate::Socks5Config,
571        timeout: Option<Duration>,
572        auth_provider: Option<AuthProvider>,
573    ) -> Result<RawClient<ElectrumSslStream>, Error> {
574        let target = target_addr.to_target_addr()?;
575
576        let mut stream = match proxy.credentials.as_ref() {
577            Some(cred) => Socks5Stream::connect_with_password(
578                &proxy.addr,
579                target_addr,
580                &cred.username,
581                &cred.password,
582                timeout,
583            )?,
584            None => Socks5Stream::connect(&proxy.addr, target.clone(), timeout)?,
585        };
586
587        stream.get_mut().set_read_timeout(timeout)?;
588        stream.get_mut().set_write_timeout(timeout)?;
589
590        RawClient::new_ssl_from_stream(target, validate_domain, stream.into_inner(), auth_provider)
591    }
592}
593
594#[derive(Debug)]
595enum ChannelMessage {
596    Response(serde_json::Value),
597    WakeUp,
598    Error(Arc<std::io::Error>),
599}
600
601impl<S: Read + Write> RawClient<S> {
602    // TODO: to enable this we have to find a way to allow concurrent read and writes to the
603    // underlying transport struct. This can be done pretty easily for TcpStream because it can be
604    // split into a "read" and a "write" object, but it's not as trivial for other types. Without
605    // such thing, this causes a deadlock, because the reader thread takes a lock on the
606    // `ClonableStream` before other threads can send a request to the server. They will block
607    // waiting for the reader to release the mutex, but this will never happen because the server
608    // didn't receive any request, so it has nothing to send back.
609    //
610    // pub fn reader_thread(&self) -> Result<(), Error> {
611    //     self._reader_thread(None).map(|_| ())
612    // }
613
614    /// Sets the [`AuthProvider`] for this client, enabling authentication on all
615    /// outgoing RPC requests.
616    ///
617    /// The `auth_provider` is a callback invoked before each request, allowing
618    /// dynamic token strategies such as automatic JWT refresh without
619    /// reconnecting the client. Passing `None` or not calling this method
620    /// disables authentication.
621    ///
622    /// # Notes
623    ///
624    /// This method should be called **before** [`RawClient::negotiate_protocol_version`],
625    /// as the initial `server.version` handshake also requires authentication
626    /// on protected servers.
627    fn with_auth(mut self, auth_provider: Option<AuthProvider>) -> Self {
628        self.auth_provider = auth_provider;
629        self
630    }
631
632    /// Negotiates the Electrum protocol version with the Electrum server.
633    ///
634    /// This sends `server.version` as the first message and stores the negotiated
635    /// protocol version.
636    ///
637    /// As of Electrum Protocol v1.6 it's a mandatory step, see:
638    /// <https://electrum-protocol.readthedocs.io/en/latest/protocol-changes.html#version-1-6>
639    ///
640    /// [`ClientType`]: crate::ClientType
641    fn negotiate_protocol_version(self) -> Result<Self, Error> {
642        let response = self.request_server_version()?;
643
644        self.cache_protocol_version(response.protocol_version)?;
645        Ok(self)
646    }
647
648    fn request_server_version(&self) -> Result<ServerVersionRes, Error> {
649        let version_range = vec![
650            PROTOCOL_VERSION_MIN.to_string(),
651            PROTOCOL_VERSION_MAX.to_string(),
652        ];
653        let req = Request::new_id(
654            self.last_id.fetch_add(1, Ordering::SeqCst),
655            "server.version",
656            vec![
657                Param::String(CLIENT_NAME.to_string()),
658                Param::StringVec(version_range),
659            ],
660        );
661        let result = self.call(req)?;
662
663        Ok(serde_json::from_value(result)?)
664    }
665
666    fn cache_protocol_version(&self, protocol_version: String) -> Result<String, Error> {
667        *self.protocol_version.lock()? = Some(protocol_version.clone());
668
669        Ok(protocol_version)
670    }
671
672    fn _reader_thread(&self, until_message: Option<usize>) -> Result<serde_json::Value, Error> {
673        let mut raw_resp = String::new();
674        let resp = match self.buf_reader.try_lock() {
675            Ok(mut reader) => {
676                trace!(
677                    "Starting reader thread with `until_message` = {:?}",
678                    until_message
679                );
680
681                if let Some(until_message) = until_message {
682                    // If we are trying to start a reader thread but the corresponding sender is
683                    // missing from the map, exit immediately. We might have already received a
684                    // response for that id, but we don't know it yet. Exiting here forces the
685                    // calling code to fallback to the sender-receiver method, and it should find
686                    // a message there waiting for it.
687                    if self.waiting_map.lock()?.get(&until_message).is_none() {
688                        return Err(Error::CouldntLockReader);
689                    }
690                }
691
692                // Loop over every message
693                loop {
694                    raw_resp.clear();
695
696                    let read_result = reader.read_line(&mut raw_resp).and_then(|bytes_read| {
697                        if bytes_read == 0 {
698                            trace!("Reached UnexpectedEof");
699                            Err(std::io::Error::new(
700                                std::io::ErrorKind::UnexpectedEof,
701                                "unexpected EOF",
702                            ))
703                        } else {
704                            Ok(())
705                        }
706                    });
707                    if let Err(e) = read_result {
708                        let error = Arc::new(e);
709                        for (_, s) in self.waiting_map.lock().unwrap().drain() {
710                            s.send(ChannelMessage::Error(error.clone()))?;
711                        }
712                        return Err(Error::SharedIOError(error));
713                    }
714                    trace!("<== {}", raw_resp);
715
716                    let resp: serde_json::Value = serde_json::from_str(&raw_resp)?;
717
718                    // Normally there is and id, but it's missing for spontaneous notifications
719                    // from the server
720                    let resp_id = resp["id"]
721                        .as_str()
722                        .and_then(|s| s.parse().ok())
723                        .or_else(|| resp["id"].as_u64().map(|i| i as usize));
724                    match resp_id {
725                        Some(resp_id) if until_message == Some(resp_id) => {
726                            // We have a valid id and it's exactly the one we were waiting for!
727                            trace!(
728                                "Reader thread {} received a response for its request",
729                                resp_id
730                            );
731
732                            // Remove ourselves from the "waiting map"
733                            let mut map = self.waiting_map.lock()?;
734                            map.remove(&resp_id);
735
736                            // If the map is not empty, we select a random thread to become the
737                            // new reader thread.
738                            if let Some(err) = map.values().find_map(|sender| {
739                                sender
740                                    .send(ChannelMessage::WakeUp)
741                                    .map_err(|err| {
742                                        warn!("Unable to wake up a thread, trying some other");
743                                        err
744                                    })
745                                    .err()
746                            }) {
747                                error!("All the threads has failed, giving up");
748                                return Err(err)?;
749                            }
750
751                            break Ok(resp);
752                        }
753                        Some(resp_id) => {
754                            // We have an id, but it's not our response. Notify the thread and
755                            // move on
756                            trace!("Reader thread received response for {}", resp_id);
757
758                            if let Some(sender) = self.waiting_map.lock()?.remove(&resp_id) {
759                                sender.send(ChannelMessage::Response(resp))?;
760                            } else {
761                                warn!("Missing listener for {}", resp_id);
762                            }
763                        }
764                        None => {
765                            // No id, that's probably a notification.
766                            let mut resp = resp;
767
768                            if let Some(method) = resp["method"].take().as_str() {
769                                self.handle_notification(method, resp["params"].take())?;
770                            } else {
771                                warn!("Unexpected response: {:?}", resp);
772                            }
773                        }
774                    }
775                }
776            }
777            Err(TryLockError::WouldBlock) => {
778                // If we "WouldBlock" here it means that there's already a reader thread
779                // running somewhere.
780                Err(Error::CouldntLockReader)
781            }
782            Err(TryLockError::Poisoned(e)) => Err(e)?,
783        };
784
785        let resp = resp?;
786        if let Some(err) = resp.get("error") {
787            Err(Error::Protocol(err.clone()))
788        } else {
789            Ok(resp)
790        }
791    }
792
793    fn call(&self, req: Request) -> Result<serde_json::Value, Error> {
794        // Add our listener to the map before we send the request, to make sure we don't get a
795        // reply before the receiver is added
796        let (sender, receiver) = channel();
797        self.waiting_map.lock()?.insert(req.id, sender);
798
799        // apply `authorization` token into `Request`, if any.
800        let authorization = self
801            .auth_provider
802            .as_ref()
803            .and_then(|auth_provider| auth_provider());
804
805        let req = req.with_auth(authorization);
806
807        let mut raw = serde_json::to_vec(&req)?;
808        trace!("==> {}", serde_json::to_string(&req.redacted())?);
809
810        raw.extend_from_slice(b"\n");
811        let mut stream = self.stream.lock()?;
812        stream.write_all(&raw)?;
813        stream.flush()?;
814        drop(stream); // release the lock
815
816        self.increment_calls();
817
818        let mut resp = match self.recv(&receiver, req.id) {
819            Ok(resp) => resp,
820            e @ Err(_) => {
821                // In case of error our sender could still be left in the map, depending on where
822                // the error happened. Just in case, try to remove it here
823                self.waiting_map.lock()?.remove(&req.id);
824                return e;
825            }
826        };
827        Ok(resp["result"].take())
828    }
829
830    fn recv(
831        &self,
832        receiver: &Receiver<ChannelMessage>,
833        req_id: usize,
834    ) -> Result<serde_json::Value, Error> {
835        loop {
836            // Try to take the lock on the reader. If we manage to do so, we'll become the reader
837            // thread until we get our reponse
838            match self._reader_thread(Some(req_id)) {
839                Ok(response) => break Ok(response),
840                Err(Error::CouldntLockReader) => {
841                    match receiver.recv()? {
842                        // Received our response, returning it
843                        ChannelMessage::Response(received) => break Ok(received),
844                        ChannelMessage::WakeUp => {
845                            // We have been woken up, this means that we should try becoming the
846                            // reader thread ourselves
847                            trace!("WakeUp for {}", req_id);
848
849                            continue;
850                        }
851                        ChannelMessage::Error(e) => {
852                            warn!("Received ChannelMessage::Error");
853
854                            break Err(Error::SharedIOError(e));
855                        }
856                    }
857                }
858                e @ Err(_) => break e,
859            }
860        }
861    }
862
863    fn handle_notification(&self, method: &str, result: serde_json::Value) -> Result<(), Error> {
864        match method {
865            "blockchain.headers.subscribe" => self.headers.lock()?.append(
866                &mut serde_json::from_value::<Vec<RawHeaderNotification>>(result)?
867                    .into_iter()
868                    .collect(),
869            ),
870            "blockchain.scripthash.subscribe" => {
871                let unserialized: ScriptNotification = serde_json::from_value(result)?;
872                let mut script_notifications = self.script_notifications.lock()?;
873
874                let queue = script_notifications
875                    .get_mut(&unserialized.scripthash)
876                    .ok_or(Error::NotSubscribed(unserialized.scripthash))?;
877
878                queue.push_back(unserialized.status);
879            }
880            _ => info!("received unknown notification for method `{}`", method),
881        }
882
883        Ok(())
884    }
885
886    pub(crate) fn internal_raw_call_with_vec(
887        &self,
888        method_name: &str,
889        params: Vec<Param>,
890    ) -> Result<serde_json::Value, Error> {
891        let req = Request::new_id(
892            self.last_id.fetch_add(1, Ordering::SeqCst),
893            method_name,
894            params,
895        );
896        let result = self.call(req)?;
897
898        Ok(result)
899    }
900
901    #[inline]
902    fn increment_calls(&self) {
903        self.calls.fetch_add(1, Ordering::SeqCst);
904    }
905}
906
907impl<T: Read + Write> ElectrumApi for RawClient<T> {
908    fn raw_call(
909        &self,
910        method_name: &str,
911        params: impl IntoIterator<Item = Param>,
912    ) -> Result<serde_json::Value, Error> {
913        self.internal_raw_call_with_vec(method_name, params.into_iter().collect())
914    }
915
916    fn batch_call(&self, batch: &Batch) -> Result<Vec<serde_json::Value>, Error> {
917        let mut requests = Vec::new();
918
919        let mut missing_responses = Vec::new();
920        let mut answers = BTreeMap::new();
921
922        // Add our listener to the map before we send the request
923
924        for (idx, (method, params)) in batch.iter().enumerate() {
925            let mut req = Request::new_id(
926                self.last_id.fetch_add(1, Ordering::SeqCst),
927                method,
928                params.to_vec(),
929            );
930
931            // Although the library DOES NOT use JSON-RPC batch arrays,
932            // It applies the `authorization` ONLY in the first `Request` of the `Batch`.
933            //
934            // JWT tokens can be 1KB+, therefore duplicating it across multiple requests adds significant overhead.
935            // It assumes the server authenticates the `Batch` by the first `Request`. If a server implementation treats
936            // each newline-delimited request independently, subsequently `Request`'s would be unauthenticated.
937            //
938            // It's a known trade-off, not a bug.
939            if idx == 0 {
940                // it should get the `authorization`, if there's an `auth_provider` available.
941                let authorization = self
942                    .auth_provider
943                    .as_ref()
944                    .and_then(|auth_provider| auth_provider());
945
946                req = req.with_auth(authorization);
947            }
948
949            // Add distinct channel to each request so when we remove our request id (and sender) from the waiting_map
950            // we can be sure that the response gets sent to the correct channel in self.recv
951            let (sender, receiver) = channel();
952            missing_responses.push((req.id, receiver));
953
954            self.waiting_map.lock()?.insert(req.id, sender);
955
956            requests.push(req);
957        }
958
959        if missing_responses.is_empty() {
960            return Ok(vec![]);
961        }
962
963        let mut raw = Vec::new();
964        for req in &requests {
965            raw.append(&mut serde_json::to_vec(req)?);
966            raw.extend_from_slice(b"\n");
967        }
968
969        trace!(
970            "==> {}",
971            requests
972                .iter()
973                .map(|req| serde_json::to_string(&req.redacted()))
974                .collect::<Result<Vec<String>, _>>()?
975                .join("\n")
976        );
977
978        let mut stream = self.stream.lock()?;
979        stream.write_all(&raw)?;
980        stream.flush()?;
981        drop(stream); // release the lock
982
983        self.increment_calls();
984
985        for (req_id, receiver) in missing_responses.iter() {
986            match self.recv(receiver, *req_id) {
987                Ok(mut resp) => answers.insert(req_id, resp["result"].take()),
988                Err(e) => {
989                    // In case of error our sender could still be left in the map, depending on where
990                    // the error happened. Just in case, try to remove it here
991                    warn!("got error for req_id {}: {:?}", req_id, e);
992                    warn!("removing all waiting req of this batch");
993                    let mut guard = self.waiting_map.lock()?;
994                    for (req_id, _) in missing_responses.iter() {
995                        guard.remove(req_id);
996                    }
997                    return Err(e);
998                }
999            };
1000        }
1001
1002        Ok(answers.into_values().collect())
1003    }
1004
1005    fn block_headers_subscribe_raw(&self) -> Result<RawHeaderNotification, Error> {
1006        let req = Request::new_id(
1007            self.last_id.fetch_add(1, Ordering::SeqCst),
1008            "blockchain.headers.subscribe",
1009            vec![],
1010        );
1011        let value = self.call(req)?;
1012
1013        Ok(serde_json::from_value(value)?)
1014    }
1015
1016    fn block_headers_pop_raw(&self) -> Result<Option<RawHeaderNotification>, Error> {
1017        Ok(self.headers.lock()?.pop_front())
1018    }
1019
1020    fn block_header_raw(&self, height: usize) -> Result<Vec<u8>, Error> {
1021        let req = Request::new_id(
1022            self.last_id.fetch_add(1, Ordering::SeqCst),
1023            "blockchain.block.header",
1024            vec![Param::Usize(height)],
1025        );
1026        let result = self.call(req)?;
1027
1028        Ok(Vec::<u8>::from_hex(
1029            result
1030                .as_str()
1031                .ok_or_else(|| Error::InvalidResponse(result.clone()))?,
1032        )?)
1033    }
1034
1035    fn block_headers(&self, start_height: usize, count: usize) -> Result<GetHeadersRes, Error> {
1036        let req = Request::new_id(
1037            self.last_id.fetch_add(1, Ordering::SeqCst),
1038            "blockchain.block.headers",
1039            vec![Param::Usize(start_height), Param::Usize(count)],
1040        );
1041        let result = self.call(req)?;
1042
1043        // Check protocol version to determine response format
1044        let is_v1_6_or_later = {
1045            let protocol_version = self.protocol_version.lock()?;
1046            protocol_version
1047                .as_ref()
1048                .map(|v| is_protocol_version_at_least(v, 1, 6))
1049                .unwrap_or(false)
1050        };
1051
1052        if is_v1_6_or_later {
1053            // v1.6+: headers field contains array of hex strings
1054            let mut deserialized: GetHeadersRes = serde_json::from_value(result)?;
1055            for header_hex in &deserialized.header_hexes {
1056                let header_bytes = Vec::<u8>::from_hex(header_hex)?;
1057                deserialized.headers.push(deserialize(&header_bytes)?);
1058            }
1059            deserialized.header_hexes.clear();
1060            Ok(deserialized)
1061        } else {
1062            // v1.4: hex field contains concatenated headers
1063            let deserialized: GetHeadersResLegacy = serde_json::from_value(result)?;
1064            let mut headers = Vec::new();
1065            for i in 0..deserialized.count {
1066                let (start, end) = (i * 80, (i + 1) * 80);
1067                headers.push(deserialize(&deserialized.raw_headers[start..end])?);
1068            }
1069            Ok(GetHeadersRes {
1070                max: deserialized.max,
1071                count: deserialized.count,
1072                header_hexes: Vec::new(),
1073                headers,
1074            })
1075        }
1076    }
1077
1078    fn estimate_fee(&self, number: usize, mode: Option<EstimationMode>) -> Result<f64, Error> {
1079        let mut params = vec![Param::Usize(number)];
1080        if let Some(mode) = mode {
1081            params.push(Param::String(mode.to_string()));
1082        }
1083        let req = Request::new_id(
1084            self.last_id.fetch_add(1, Ordering::SeqCst),
1085            "blockchain.estimatefee",
1086            params,
1087        );
1088        let result = self.call(req)?;
1089
1090        result
1091            .as_f64()
1092            .ok_or_else(|| Error::InvalidResponse(result.clone()))
1093    }
1094
1095    fn relay_fee(&self) -> Result<f64, Error> {
1096        let req = Request::new_id(
1097            self.last_id.fetch_add(1, Ordering::SeqCst),
1098            "blockchain.relayfee",
1099            vec![],
1100        );
1101        let result = self.call(req)?;
1102
1103        result
1104            .as_f64()
1105            .ok_or_else(|| Error::InvalidResponse(result.clone()))
1106    }
1107
1108    fn script_subscribe(&self, script: &Script) -> Result<Option<ScriptStatus>, Error> {
1109        let script_hash = script.to_electrum_scripthash();
1110        let mut script_notifications = self.script_notifications.lock()?;
1111
1112        if script_notifications.contains_key(&script_hash) {
1113            return Err(Error::AlreadySubscribed(script_hash));
1114        }
1115
1116        script_notifications.insert(script_hash, VecDeque::new());
1117        drop(script_notifications);
1118
1119        let req = Request::new_id(
1120            self.last_id.fetch_add(1, Ordering::SeqCst),
1121            "blockchain.scripthash.subscribe",
1122            vec![Param::String(script_hash.to_hex())],
1123        );
1124        let value = self.call(req)?;
1125
1126        Ok(serde_json::from_value(value)?)
1127    }
1128
1129    fn batch_script_subscribe<'s, I>(&self, scripts: I) -> Result<Vec<Option<ScriptStatus>>, Error>
1130    where
1131        I: IntoIterator + Clone,
1132        I::Item: Borrow<&'s Script>,
1133    {
1134        {
1135            let mut script_notifications = self.script_notifications.lock()?;
1136
1137            for script in scripts.clone() {
1138                let script_hash = script.borrow().to_electrum_scripthash();
1139                if script_notifications.contains_key(&script_hash) {
1140                    return Err(Error::AlreadySubscribed(script_hash));
1141                }
1142                script_notifications.insert(script_hash, VecDeque::new());
1143            }
1144        }
1145        impl_batch_call!(self, scripts, script_subscribe)
1146    }
1147
1148    fn script_unsubscribe(&self, script: &Script) -> Result<bool, Error> {
1149        let script_hash = script.to_electrum_scripthash();
1150        let mut script_notifications = self.script_notifications.lock()?;
1151
1152        if !script_notifications.contains_key(&script_hash) {
1153            return Err(Error::NotSubscribed(script_hash));
1154        }
1155
1156        let req = Request::new_id(
1157            self.last_id.fetch_add(1, Ordering::SeqCst),
1158            "blockchain.scripthash.unsubscribe",
1159            vec![Param::String(script_hash.to_hex())],
1160        );
1161        let value = self.call(req)?;
1162        let answer = serde_json::from_value(value)?;
1163
1164        script_notifications.remove(&script_hash);
1165
1166        Ok(answer)
1167    }
1168
1169    fn script_pop(&self, script: &Script) -> Result<Option<ScriptStatus>, Error> {
1170        let script_hash = script.to_electrum_scripthash();
1171
1172        match self.script_notifications.lock()?.get_mut(&script_hash) {
1173            None => Err(Error::NotSubscribed(script_hash)),
1174            Some(queue) => Ok(queue.pop_front()),
1175        }
1176    }
1177
1178    fn script_get_balance(&self, script: &Script) -> Result<GetBalanceRes, Error> {
1179        let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
1180        let req = Request::new_id(
1181            self.last_id.fetch_add(1, Ordering::SeqCst),
1182            "blockchain.scripthash.get_balance",
1183            params,
1184        );
1185        let result = self.call(req)?;
1186
1187        Ok(serde_json::from_value(result)?)
1188    }
1189    fn batch_script_get_balance<'s, I>(&self, scripts: I) -> Result<Vec<GetBalanceRes>, Error>
1190    where
1191        I: IntoIterator + Clone,
1192        I::Item: Borrow<&'s Script>,
1193    {
1194        impl_batch_call!(self, scripts, script_get_balance)
1195    }
1196
1197    fn script_get_history(&self, script: &Script) -> Result<Vec<GetHistoryRes>, Error> {
1198        let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
1199        let req = Request::new_id(
1200            self.last_id.fetch_add(1, Ordering::SeqCst),
1201            "blockchain.scripthash.get_history",
1202            params,
1203        );
1204        let result = self.call(req)?;
1205
1206        Ok(serde_json::from_value(result)?)
1207    }
1208    fn batch_script_get_history<'s, I>(&self, scripts: I) -> Result<Vec<Vec<GetHistoryRes>>, Error>
1209    where
1210        I: IntoIterator + Clone,
1211        I::Item: Borrow<&'s Script>,
1212    {
1213        impl_batch_call!(self, scripts, script_get_history)
1214    }
1215
1216    fn script_list_unspent(&self, script: &Script) -> Result<Vec<ListUnspentRes>, Error> {
1217        let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
1218        let req = Request::new_id(
1219            self.last_id.fetch_add(1, Ordering::SeqCst),
1220            "blockchain.scripthash.listunspent",
1221            params,
1222        );
1223        let result = self.call(req)?;
1224        let mut result: Vec<ListUnspentRes> = serde_json::from_value(result)?;
1225
1226        // This should not be necessary, since the protocol documentation says that the txs should
1227        // be "in blockchain order" (https://electrumx.readthedocs.io/en/latest/protocol-methods.html#blockchain-scripthash-listunspent).
1228        // However, elects seems to be ignoring this at the moment, so we'll sort again here just
1229        // to make sure the result is consistent.
1230        result.sort_unstable_by_key(|k| (k.height, k.tx_pos));
1231        Ok(result)
1232    }
1233
1234    fn batch_script_list_unspent<'s, I>(
1235        &self,
1236        scripts: I,
1237    ) -> Result<Vec<Vec<ListUnspentRes>>, Error>
1238    where
1239        I: IntoIterator + Clone,
1240        I::Item: Borrow<&'s Script>,
1241    {
1242        impl_batch_call!(self, scripts, script_list_unspent)
1243    }
1244
1245    fn transaction_get_raw(&self, txid: &Txid) -> Result<Vec<u8>, Error> {
1246        let params = vec![Param::String(format!("{:x}", txid))];
1247        let req = Request::new_id(
1248            self.last_id.fetch_add(1, Ordering::SeqCst),
1249            "blockchain.transaction.get",
1250            params,
1251        );
1252        let result = self.call(req)?;
1253
1254        Ok(Vec::<u8>::from_hex(
1255            result
1256                .as_str()
1257                .ok_or_else(|| Error::InvalidResponse(result.clone()))?,
1258        )?)
1259    }
1260
1261    fn batch_transaction_get_raw<'t, I>(&self, txids: I) -> Result<Vec<Vec<u8>>, Error>
1262    where
1263        I: IntoIterator + Clone,
1264        I::Item: Borrow<&'t Txid>,
1265    {
1266        let txs_string: Result<Vec<String>, Error> = impl_batch_call!(self, txids, transaction_get);
1267        txs_string?
1268            .iter()
1269            .map(|s| Ok(Vec::<u8>::from_hex(s)?))
1270            .collect()
1271    }
1272
1273    fn batch_block_header_raw<'s, I>(&self, heights: I) -> Result<Vec<Vec<u8>>, Error>
1274    where
1275        I: IntoIterator + Clone,
1276        I::Item: Borrow<u32>,
1277    {
1278        let headers_string: Result<Vec<String>, Error> =
1279            impl_batch_call!(self, heights, block_header, apply_deref);
1280        headers_string?
1281            .iter()
1282            .map(|s| Ok(Vec::<u8>::from_hex(s)?))
1283            .collect()
1284    }
1285
1286    fn batch_estimate_fee<'s, I>(&self, numbers: I) -> Result<Vec<f64>, Error>
1287    where
1288        I: IntoIterator + Clone,
1289        I::Item: Borrow<usize>,
1290    {
1291        let mut batch = Batch::default();
1292        for i in numbers {
1293            batch.estimate_fee(*i.borrow(), None);
1294        }
1295
1296        let resp = self.batch_call(&batch)?;
1297        let mut answer = Vec::new();
1298
1299        for x in resp {
1300            answer.push(serde_json::from_value(x)?);
1301        }
1302
1303        Ok(answer)
1304    }
1305
1306    fn transaction_broadcast_raw(&self, raw_tx: &[u8]) -> Result<Txid, Error> {
1307        let params = vec![Param::String(raw_tx.to_lower_hex_string())];
1308        let req = Request::new_id(
1309            self.last_id.fetch_add(1, Ordering::SeqCst),
1310            "blockchain.transaction.broadcast",
1311            params,
1312        );
1313        let result = self.call(req)?;
1314
1315        Ok(serde_json::from_value(result)?)
1316    }
1317
1318    fn transaction_broadcast_package_raw<Tx: AsRef<[u8]>>(
1319        &self,
1320        raw_txs: &[Tx],
1321    ) -> Result<BroadcastPackageRes, Error> {
1322        let hex_txs: Vec<String> = raw_txs
1323            .iter()
1324            .map(|tx| tx.as_ref().to_lower_hex_string())
1325            .collect();
1326        let params = vec![Param::StringVec(hex_txs)];
1327        let req = Request::new_id(
1328            self.last_id.fetch_add(1, Ordering::SeqCst),
1329            "blockchain.transaction.broadcast_package",
1330            params,
1331        );
1332        let result = self.call(req)?;
1333
1334        Ok(serde_json::from_value(result)?)
1335    }
1336
1337    fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error> {
1338        let params = vec![Param::String(format!("{:x}", txid)), Param::Usize(height)];
1339        let req = Request::new_id(
1340            self.last_id.fetch_add(1, Ordering::SeqCst),
1341            "blockchain.transaction.get_merkle",
1342            params,
1343        );
1344        let result = self.call(req)?;
1345
1346        Ok(serde_json::from_value(result)?)
1347    }
1348
1349    fn batch_transaction_get_merkle<I>(
1350        &self,
1351        txids_and_heights: I,
1352    ) -> Result<Vec<GetMerkleRes>, Error>
1353    where
1354        I: IntoIterator + Clone,
1355        I::Item: Borrow<(Txid, usize)>,
1356    {
1357        impl_batch_call!(self, txids_and_heights, transaction_get_merkle)
1358    }
1359
1360    fn txid_from_pos(&self, height: usize, tx_pos: usize) -> Result<Txid, Error> {
1361        let params = vec![Param::Usize(height), Param::Usize(tx_pos)];
1362        let req = Request::new_id(
1363            self.last_id.fetch_add(1, Ordering::SeqCst),
1364            "blockchain.transaction.id_from_pos",
1365            params,
1366        );
1367        let result = self.call(req)?;
1368
1369        Ok(serde_json::from_value(result)?)
1370    }
1371
1372    fn txid_from_pos_with_merkle(
1373        &self,
1374        height: usize,
1375        tx_pos: usize,
1376    ) -> Result<TxidFromPosRes, Error> {
1377        let params = vec![
1378            Param::Usize(height),
1379            Param::Usize(tx_pos),
1380            Param::Bool(true),
1381        ];
1382        let req = Request::new_id(
1383            self.last_id.fetch_add(1, Ordering::SeqCst),
1384            "blockchain.transaction.id_from_pos",
1385            params,
1386        );
1387        let result = self.call(req)?;
1388
1389        Ok(serde_json::from_value(result)?)
1390    }
1391
1392    fn server_features(&self) -> Result<ServerFeaturesRes, Error> {
1393        let req = Request::new_id(
1394            self.last_id.fetch_add(1, Ordering::SeqCst),
1395            "server.features",
1396            vec![],
1397        );
1398        let result = self.call(req)?;
1399
1400        Ok(serde_json::from_value(result)?)
1401    }
1402
1403    fn protocol_version(&self) -> Result<String, Error> {
1404        if let Some(protocol_version) = self.protocol_version.lock()?.clone() {
1405            return Ok(protocol_version);
1406        }
1407
1408        let response = self.request_server_version()?;
1409
1410        self.cache_protocol_version(response.protocol_version)
1411    }
1412
1413    fn mempool_get_info(&self) -> Result<MempoolInfoRes, Error> {
1414        let req = Request::new_id(
1415            self.last_id.fetch_add(1, Ordering::SeqCst),
1416            "mempool.get_info",
1417            vec![],
1418        );
1419        let result = self.call(req)?;
1420
1421        Ok(serde_json::from_value(result)?)
1422    }
1423
1424    fn ping(&self) -> Result<(), Error> {
1425        let req = Request::new_id(
1426            self.last_id.fetch_add(1, Ordering::SeqCst),
1427            "server.ping",
1428            vec![],
1429        );
1430        self.call(req)?;
1431
1432        Ok(())
1433    }
1434
1435    fn calls_made(&self) -> Result<usize, Error> {
1436        Ok(self.calls.load(Ordering::SeqCst))
1437    }
1438}
1439
1440#[cfg(test)]
1441mod test {
1442    use std::{
1443        io::{self, Cursor, Read, Write},
1444        str::FromStr,
1445        sync::{mpsc, Arc, Mutex},
1446        time::Duration,
1447    };
1448
1449    use crate::utils;
1450
1451    use super::{ChannelMessage, ElectrumSslStream, RawClient};
1452    use crate::api::ElectrumApi;
1453    use crate::config::AuthProvider;
1454    use crate::Error;
1455
1456    // it's the default live testing electrum server, if you'd like to use a custom one set it up through
1457    // the environment variable `TEST_ELECTRUM_SERVER`.
1458    //
1459    // here's an useful list of live servers: https://1209k.com/bitcoin-eye/ele.php.
1460    const DEFAULT_TEST_ELECTRUM_SERVER: &str = "fortress.qtornado.com:443";
1461
1462    #[derive(Clone)]
1463    struct MockStream {
1464        responses: Arc<Mutex<Cursor<Vec<u8>>>>,
1465        requests: Arc<Mutex<Vec<u8>>>,
1466    }
1467
1468    impl MockStream {
1469        fn new(responses: impl Into<Vec<u8>>) -> Self {
1470            Self {
1471                responses: Arc::new(Mutex::new(Cursor::new(responses.into()))),
1472                requests: Arc::new(Mutex::new(Vec::new())),
1473            }
1474        }
1475
1476        fn written_requests(&self) -> Vec<serde_json::Value> {
1477            let requests = self.requests.lock().unwrap().clone();
1478            let requests = String::from_utf8(requests).unwrap();
1479
1480            requests
1481                .lines()
1482                .map(|line| serde_json::from_str(line).unwrap())
1483                .collect()
1484        }
1485    }
1486
1487    impl Read for MockStream {
1488        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1489            self.responses.lock().unwrap().read(buf)
1490        }
1491    }
1492
1493    impl Write for MockStream {
1494        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
1495            self.requests.lock().unwrap().extend_from_slice(buf);
1496
1497            Ok(buf.len())
1498        }
1499
1500        fn flush(&mut self) -> io::Result<()> {
1501            Ok(())
1502        }
1503    }
1504
1505    fn server_version_response(id: usize, protocol_version: &str) -> String {
1506        format!(
1507            r#"{{"jsonrpc":"2.0","id":{id},"result":["ElectrumX 1.18.0","{protocol_version}"]}}"#
1508        ) + "\n"
1509    }
1510
1511    fn assert_server_version_request(request: &serde_json::Value) {
1512        assert_eq!(request["method"], "server.version");
1513        assert_eq!(request["params"], serde_json::json!(["", ["1.4", "1.6"]]));
1514    }
1515
1516    #[test]
1517    fn clean_eof_wakes_all_waiting_requests() {
1518        let client = RawClient::from(MockStream::new(Vec::new()));
1519        let (first_sender, first_receiver) = mpsc::channel();
1520        let (second_sender, second_receiver) = mpsc::channel();
1521        {
1522            let mut waiting_map = client.waiting_map.lock().unwrap();
1523            waiting_map.insert(1, first_sender);
1524            waiting_map.insert(2, second_sender);
1525        }
1526
1527        let reader_error = client._reader_thread(None).unwrap_err();
1528        let first_message = first_receiver
1529            .recv_timeout(Duration::from_secs(1))
1530            .expect("clean EOF must wake the first waiting request");
1531        let second_message = second_receiver
1532            .recv_timeout(Duration::from_secs(1))
1533            .expect("clean EOF must wake the second waiting request");
1534
1535        assert!(client.waiting_map.lock().unwrap().is_empty());
1536        assert!(matches!(
1537            reader_error,
1538            Error::SharedIOError(error) if error.kind() == io::ErrorKind::UnexpectedEof
1539        ));
1540        for message in [first_message, second_message] {
1541            assert!(matches!(
1542                message,
1543                ChannelMessage::Error(error)
1544                    if error.kind() == io::ErrorKind::UnexpectedEof
1545            ));
1546        }
1547    }
1548
1549    fn get_test_auth_client(
1550        authorization_provider: Option<AuthProvider>,
1551    ) -> RawClient<ElectrumSslStream> {
1552        let server = std::env::var("TEST_ELECTRUM_SERVER")
1553            .unwrap_or(DEFAULT_TEST_ELECTRUM_SERVER.to_owned());
1554
1555        RawClient::new_ssl(&*server, false, None, authorization_provider)
1556            .expect("should build the `RawClient` successfully!")
1557    }
1558
1559    fn get_test_client() -> RawClient<ElectrumSslStream> {
1560        let server = std::env::var("TEST_ELECTRUM_SERVER")
1561            .unwrap_or(DEFAULT_TEST_ELECTRUM_SERVER.to_owned());
1562
1563        RawClient::new_ssl(&*server, false, None, None)
1564            .expect("should build the `RawClient` successfully!")
1565    }
1566
1567    #[test]
1568    fn test_protocol_version_returns_negotiated_version_without_new_request() {
1569        let stream = MockStream::new(server_version_response(0, "1.6"));
1570        let stream_handle = stream.clone();
1571        let client = RawClient::from(stream)
1572            .negotiate_protocol_version()
1573            .unwrap();
1574
1575        assert_eq!(client.protocol_version().unwrap(), "1.6");
1576        assert_eq!(client.calls_made().unwrap(), 1);
1577
1578        let requests = stream_handle.written_requests();
1579        assert_eq!(requests.len(), 1);
1580        assert_server_version_request(&requests[0]);
1581    }
1582
1583    #[test]
1584    fn test_protocol_version_fetches_and_caches_missing_version() {
1585        let stream = MockStream::new(server_version_response(0, "1.6"));
1586        let stream_handle = stream.clone();
1587        let client = RawClient::from(stream);
1588
1589        assert_eq!(client.protocol_version().unwrap(), "1.6");
1590        assert_eq!(client.protocol_version().unwrap(), "1.6");
1591        assert_eq!(client.calls_made().unwrap(), 1);
1592
1593        let requests = stream_handle.written_requests();
1594        assert_eq!(requests.len(), 1);
1595        assert_server_version_request(&requests[0]);
1596    }
1597
1598    #[test]
1599    fn test_server_features_simple() {
1600        let client = get_test_client();
1601
1602        let resp = client.server_features().unwrap();
1603        assert_eq!(
1604            resp.genesis_hash,
1605            [
1606                0, 0, 0, 0, 0, 25, 214, 104, 156, 8, 90, 225, 101, 131, 30, 147, 79, 247, 99, 174,
1607                70, 162, 166, 193, 114, 179, 241, 182, 10, 140, 226, 111
1608            ],
1609        );
1610        assert_eq!(resp.hash_function, Some("sha256".into()));
1611        assert_eq!(resp.pruning, None);
1612    }
1613
1614    #[test]
1615    fn test_mempool_get_info() {
1616        let client = get_test_client();
1617
1618        let resp = client.mempool_get_info().unwrap();
1619        assert!(resp.mempoolminfee >= 0.0);
1620        assert!(resp.minrelaytxfee >= 0.0);
1621        assert!(resp.incrementalrelayfee >= 0.0);
1622    }
1623
1624    #[test]
1625    fn test_transaction_broadcast_package() {
1626        let client = get_test_client();
1627
1628        // Empty package should return an error or unsuccessful response
1629        let resp = client.transaction_broadcast_package_raw::<Vec<u8>>(&[]);
1630        // The server may reject an empty package with a protocol error
1631        assert!(resp.is_err() || !resp.unwrap().success);
1632    }
1633
1634    #[test]
1635    #[ignore = "depends on a live server"]
1636    fn test_batch_response_ordering() {
1637        // The electrum.blockstream.info:50001 node always sends back ordered responses which will make this always pass.
1638        // However, many servers do not, so we use one of those servers for this test.
1639        let client = get_test_client();
1640        let heights: Vec<u32> = vec![1, 4, 8, 12, 222, 6666, 12];
1641        let result_times = [
1642            1231469665, 1231470988, 1231472743, 1231474888, 1231770653, 1236456633, 1231474888,
1643        ];
1644        // Check ordering 10 times. This usually fails within 5 if ordering is incorrect.
1645        for _ in 0..10 {
1646            let results = client.batch_block_header(&heights).unwrap();
1647            for (index, result) in results.iter().enumerate() {
1648                assert_eq!(result_times[index], result.time);
1649            }
1650        }
1651    }
1652
1653    #[test]
1654    fn test_estimate_fee() {
1655        let client = get_test_client();
1656
1657        let resp = client.estimate_fee(10, None).unwrap();
1658        assert!(resp > 0.0);
1659    }
1660
1661    #[test]
1662    fn test_block_header() {
1663        let client = get_test_client();
1664
1665        let resp = client.block_header(0).unwrap();
1666        assert_eq!(resp.version, bitcoin::block::Version::ONE);
1667        assert_eq!(resp.time, 1231006505);
1668        assert_eq!(resp.nonce, 0x7c2bac1d);
1669    }
1670
1671    #[test]
1672    fn test_block_header_raw() {
1673        let client = get_test_client();
1674
1675        let resp = client.block_header_raw(0).unwrap();
1676        assert_eq!(
1677            resp,
1678            vec![
1679                1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680                0, 0, 0, 0, 0, 0, 0, 0, 59, 163, 237, 253, 122, 123, 18, 178, 122, 199, 44, 62,
1681                103, 118, 143, 97, 127, 200, 27, 195, 136, 138, 81, 50, 58, 159, 184, 170, 75, 30,
1682                94, 74, 41, 171, 95, 73, 255, 255, 0, 29, 29, 172, 43, 124
1683            ]
1684        );
1685    }
1686
1687    #[test]
1688    fn test_block_headers() {
1689        let client = get_test_client();
1690
1691        let resp = client.block_headers(0, 4).unwrap();
1692        assert_eq!(resp.count, 4);
1693        assert_eq!(resp.max, 2016);
1694        assert_eq!(resp.headers.len(), 4);
1695
1696        assert_eq!(resp.headers[0].time, 1231006505);
1697    }
1698
1699    #[test]
1700    fn test_script_get_balance() {
1701        use std::str::FromStr;
1702
1703        let client = get_test_client();
1704
1705        // Realistically nobody will ever spend from this address, so we can expect the balance to
1706        // increase over time
1707        let addr = bitcoin::Address::from_str("1CounterpartyXXXXXXXXXXXXXXXUWLpVr")
1708            .unwrap()
1709            .assume_checked();
1710        let resp = client.script_get_balance(&addr.script_pubkey()).unwrap();
1711        assert!(resp.confirmed >= 213091301265);
1712    }
1713
1714    #[test]
1715    fn test_script_get_history() {
1716        use std::str::FromStr;
1717
1718        use bitcoin::Txid;
1719
1720        let client = get_test_client();
1721
1722        // Mt.Gox hack address
1723        let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF")
1724            .unwrap()
1725            .assume_checked();
1726        let resp = client.script_get_history(&addr.script_pubkey()).unwrap();
1727
1728        assert!(resp.len() >= 328);
1729        assert_eq!(
1730            resp[0].tx_hash,
1731            Txid::from_str("e67a0550848b7932d7796aeea16ab0e48a5cfe81c4e8cca2c5b03e0416850114")
1732                .unwrap()
1733        );
1734    }
1735
1736    #[test]
1737    fn test_script_list_unspent() {
1738        use bitcoin::Txid;
1739        use std::str::FromStr;
1740
1741        let client = get_test_client();
1742
1743        // Peter todd's sha256 bounty address https://bitcointalk.org/index.php?topic=293382.0
1744        let addr = bitcoin::Address::from_str("35Snmmy3uhaer2gTboc81ayCip4m9DT4ko")
1745            .unwrap()
1746            .assume_checked();
1747        let resp = client.script_list_unspent(&addr.script_pubkey()).unwrap();
1748
1749        assert!(resp.len() >= 9);
1750        let txid = "397f12ee15f8a3d2ab25c0f6bb7d3c64d2038ca056af10dd8251b98ae0f076b0";
1751        let txid = Txid::from_str(txid).unwrap();
1752        let txs: Vec<_> = resp.iter().filter(|e| e.tx_hash == txid).collect();
1753        assert_eq!(txs.len(), 1);
1754        assert_eq!(txs[0].value, 10000000);
1755        assert_eq!(txs[0].height, 257674);
1756        assert_eq!(txs[0].tx_pos, 1);
1757    }
1758
1759    #[test]
1760    fn test_batch_script_list_unspent() {
1761        use std::str::FromStr;
1762
1763        let client = get_test_client();
1764
1765        // Peter todd's sha256 bounty address https://bitcointalk.org/index.php?topic=293382.0
1766        let script_1 = bitcoin::Address::from_str("35Snmmy3uhaer2gTboc81ayCip4m9DT4ko")
1767            .unwrap()
1768            .assume_checked()
1769            .script_pubkey();
1770
1771        let resp = client
1772            .batch_script_list_unspent(vec![script_1.as_script()])
1773            .unwrap();
1774        assert_eq!(resp.len(), 1);
1775        assert!(resp[0].len() >= 9);
1776    }
1777
1778    #[test]
1779    fn test_batch_estimate_fee() {
1780        let client = get_test_client();
1781
1782        let resp = client.batch_estimate_fee(vec![10, 20]).unwrap();
1783        assert_eq!(resp.len(), 2);
1784        assert!(resp[0] > 0.0);
1785        assert!(resp[1] > 0.0);
1786    }
1787
1788    #[test]
1789    fn test_transaction_get() {
1790        use bitcoin::{transaction, Txid};
1791
1792        let client = get_test_client();
1793
1794        let resp = client
1795            .transaction_get(
1796                &Txid::from_str("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
1797                    .unwrap(),
1798            )
1799            .unwrap();
1800        assert_eq!(resp.version, transaction::Version::ONE);
1801        assert_eq!(resp.lock_time.to_consensus_u32(), 0);
1802    }
1803
1804    #[test]
1805    fn test_transaction_get_raw() {
1806        use bitcoin::Txid;
1807
1808        let client = get_test_client();
1809
1810        let resp = client
1811            .transaction_get_raw(
1812                &Txid::from_str("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
1813                    .unwrap(),
1814            )
1815            .unwrap();
1816        assert_eq!(
1817            resp,
1818            vec![
1819                1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1820                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 84, 3, 240, 156, 9, 27, 77,
1821                105, 110, 101, 100, 32, 98, 121, 32, 65, 110, 116, 80, 111, 111, 108, 49, 49, 57,
1822                174, 0, 111, 32, 7, 77, 101, 40, 250, 190, 109, 109, 42, 177, 148, 141, 80, 179,
1823                217, 145, 226, 160, 130, 29, 247, 67, 88, 237, 156, 37, 83, 175, 0, 199, 166, 31,
1824                151, 119, 28, 160, 172, 238, 16, 110, 4, 0, 0, 0, 0, 0, 0, 0, 203, 236, 0, 128, 36,
1825                97, 249, 5, 255, 255, 255, 255, 3, 84, 206, 172, 42, 0, 0, 0, 0, 25, 118, 169, 20,
1826                17, 219, 228, 140, 198, 182, 23, 249, 198, 173, 175, 77, 158, 213, 246, 37, 177,
1827                199, 203, 89, 136, 172, 0, 0, 0, 0, 0, 0, 0, 0, 38, 106, 36, 170, 33, 169, 237, 46,
1828                87, 139, 206, 44, 166, 198, 188, 147, 89, 55, 115, 69, 216, 233, 133, 221, 95, 144,
1829                199, 132, 33, 255, 166, 239, 165, 235, 96, 66, 142, 105, 140, 0, 0, 0, 0, 0, 0, 0,
1830                0, 38, 106, 36, 185, 225, 27, 109, 47, 98, 29, 126, 195, 244, 90, 94, 202, 137,
1831                211, 234, 106, 41, 76, 223, 58, 4, 46, 151, 48, 9, 88, 68, 112, 161, 41, 22, 17,
1832                30, 44, 170, 1, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1833                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1834            ]
1835        )
1836    }
1837
1838    #[test]
1839    fn test_transaction_get_merkle() {
1840        use bitcoin::Txid;
1841
1842        let client = get_test_client();
1843
1844        let txid =
1845            Txid::from_str("1f7ff3c407f33eabc8bec7d2cc230948f2249ec8e591bcf6f971ca9366c8788d")
1846                .unwrap();
1847        let resp = client.transaction_get_merkle(&txid, 630000).unwrap();
1848        assert_eq!(resp.block_height, 630000);
1849        assert_eq!(resp.pos, 68);
1850        assert_eq!(resp.merkle.len(), 12);
1851        assert_eq!(
1852            resp.merkle[0],
1853            [
1854                34, 65, 51, 64, 49, 139, 115, 189, 185, 246, 70, 225, 168, 193, 217, 195, 47, 66,
1855                179, 240, 153, 24, 114, 215, 144, 196, 212, 41, 39, 155, 246, 25
1856            ]
1857        );
1858
1859        // Check we can verify the merkle proof validity, but fail if we supply wrong data.
1860        let block_header = client.block_header(resp.block_height).unwrap();
1861        assert!(utils::validate_merkle_proof(
1862            &txid,
1863            &block_header.merkle_root,
1864            &resp
1865        ));
1866
1867        let mut fail_resp = resp.clone();
1868        fail_resp.pos = 13;
1869        assert!(!utils::validate_merkle_proof(
1870            &txid,
1871            &block_header.merkle_root,
1872            &fail_resp
1873        ));
1874
1875        let fail_block_header = client.block_header(resp.block_height + 1).unwrap();
1876        assert!(!utils::validate_merkle_proof(
1877            &txid,
1878            &fail_block_header.merkle_root,
1879            &resp
1880        ));
1881    }
1882
1883    #[test]
1884    fn test_batch_transaction_get_merkle() {
1885        use bitcoin::Txid;
1886
1887        struct TestCase {
1888            txid: Txid,
1889            block_height: usize,
1890            exp_pos: usize,
1891            exp_bytes: [u8; 32],
1892        }
1893
1894        let client = get_test_client();
1895
1896        let test_cases: Vec<TestCase> = vec![
1897            TestCase {
1898                txid: Txid::from_str(
1899                    "1f7ff3c407f33eabc8bec7d2cc230948f2249ec8e591bcf6f971ca9366c8788d",
1900                )
1901                .unwrap(),
1902                block_height: 630000,
1903                exp_pos: 68,
1904                exp_bytes: [
1905                    34, 65, 51, 64, 49, 139, 115, 189, 185, 246, 70, 225, 168, 193, 217, 195, 47,
1906                    66, 179, 240, 153, 24, 114, 215, 144, 196, 212, 41, 39, 155, 246, 25,
1907                ],
1908            },
1909            TestCase {
1910                txid: Txid::from_str(
1911                    "70a8639bc9b743c0610d1231103a2f8e99f4a25670946b91f16c55a5373b37d1",
1912                )
1913                .unwrap(),
1914                block_height: 630001,
1915                exp_pos: 25,
1916                exp_bytes: [
1917                    169, 100, 34, 99, 168, 101, 25, 168, 184, 90, 77, 50, 151, 245, 130, 101, 193,
1918                    229, 136, 128, 63, 110, 241, 19, 242, 59, 184, 137, 245, 249, 188, 110,
1919                ],
1920            },
1921            TestCase {
1922                txid: Txid::from_str(
1923                    "a0db149ace545beabbd87a8d6b20ffd6aa3b5a50e58add49a3d435f898c272cf",
1924                )
1925                .unwrap(),
1926                block_height: 840000,
1927                exp_pos: 0,
1928                exp_bytes: [
1929                    43, 184, 95, 75, 0, 75, 230, 218, 84, 247, 102, 193, 124, 30, 133, 81, 135, 50,
1930                    113, 18, 194, 49, 239, 47, 243, 94, 186, 208, 234, 103, 198, 158,
1931                ],
1932            },
1933        ];
1934
1935        let txids_and_heights: Vec<(Txid, usize)> = test_cases
1936            .iter()
1937            .map(|case| (case.txid, case.block_height))
1938            .collect();
1939
1940        let resp = client
1941            .batch_transaction_get_merkle(&txids_and_heights)
1942            .unwrap();
1943
1944        for (i, (res, test_case)) in resp.iter().zip(test_cases).enumerate() {
1945            assert_eq!(res.block_height, test_case.block_height);
1946            assert_eq!(res.pos, test_case.exp_pos);
1947            assert_eq!(res.merkle.len(), 12);
1948            assert_eq!(res.merkle[0], test_case.exp_bytes);
1949
1950            // Check we can verify the merkle proof validity, but fail if we supply wrong data.
1951            let block_header = client.block_header(res.block_height).unwrap();
1952            assert!(utils::validate_merkle_proof(
1953                &txids_and_heights[i].0,
1954                &block_header.merkle_root,
1955                res
1956            ));
1957
1958            let mut fail_res = res.clone();
1959            fail_res.pos = 13;
1960            assert!(!utils::validate_merkle_proof(
1961                &txids_and_heights[i].0,
1962                &block_header.merkle_root,
1963                &fail_res
1964            ));
1965
1966            let fail_block_header = client.block_header(res.block_height + 1).unwrap();
1967            assert!(!utils::validate_merkle_proof(
1968                &txids_and_heights[i].0,
1969                &fail_block_header.merkle_root,
1970                res
1971            ));
1972        }
1973    }
1974
1975    #[test]
1976    fn test_txid_from_pos() {
1977        use bitcoin::Txid;
1978
1979        let client = get_test_client();
1980
1981        let txid =
1982            Txid::from_str("1f7ff3c407f33eabc8bec7d2cc230948f2249ec8e591bcf6f971ca9366c8788d")
1983                .unwrap();
1984        let resp = client.txid_from_pos(630000, 68).unwrap();
1985        assert_eq!(resp, txid);
1986    }
1987
1988    #[test]
1989    fn test_txid_from_pos_with_merkle() {
1990        use bitcoin::Txid;
1991
1992        let client = get_test_client();
1993
1994        let txid =
1995            Txid::from_str("1f7ff3c407f33eabc8bec7d2cc230948f2249ec8e591bcf6f971ca9366c8788d")
1996                .unwrap();
1997        let resp = client.txid_from_pos_with_merkle(630000, 68).unwrap();
1998        assert_eq!(resp.tx_hash, txid);
1999        assert_eq!(
2000            resp.merkle[0],
2001            [
2002                34, 65, 51, 64, 49, 139, 115, 189, 185, 246, 70, 225, 168, 193, 217, 195, 47, 66,
2003                179, 240, 153, 24, 114, 215, 144, 196, 212, 41, 39, 155, 246, 25
2004            ]
2005        );
2006    }
2007
2008    #[test]
2009    fn test_ping() {
2010        let client = get_test_client();
2011        client.ping().unwrap();
2012    }
2013
2014    #[test]
2015    fn test_block_headers_subscribe() {
2016        let client = get_test_client();
2017        let resp = client.block_headers_subscribe().unwrap();
2018
2019        assert!(resp.height >= 639000);
2020    }
2021
2022    #[test]
2023    fn test_script_subscribe() {
2024        use std::str::FromStr;
2025
2026        let client = get_test_client();
2027
2028        // Mt.Gox hack address
2029        let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF")
2030            .unwrap()
2031            .assume_checked();
2032
2033        // Just make sure that the call returns Ok(something)
2034        client.script_subscribe(&addr.script_pubkey()).unwrap();
2035    }
2036
2037    #[test]
2038    fn test_request_after_error() {
2039        let client = get_test_client();
2040
2041        assert!(client.transaction_broadcast_raw(&[0x00]).is_err());
2042        assert!(client.server_features().is_ok());
2043    }
2044
2045    #[test]
2046    fn test_raw_call() {
2047        use crate::types::Param;
2048
2049        let client = get_test_client();
2050
2051        let params = vec![
2052            Param::String(
2053                "cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566".to_string(),
2054            ),
2055            Param::Bool(false),
2056        ];
2057
2058        let resp = client
2059            .raw_call("blockchain.transaction.get", params)
2060            .unwrap();
2061
2062        assert_eq!(
2063            resp,
2064            "01000000000101000000000000000000000000000000000000000000000000000\
2065            0000000000000ffffffff5403f09c091b4d696e656420627920416e74506f6f6c3\
2066            13139ae006f20074d6528fabe6d6d2ab1948d50b3d991e2a0821df74358ed9c255\
2067            3af00c7a61f97771ca0acee106e0400000000000000cbec00802461f905fffffff\
2068            f0354ceac2a000000001976a91411dbe48cc6b617f9c6adaf4d9ed5f625b1c7cb5\
2069            988ac0000000000000000266a24aa21a9ed2e578bce2ca6c6bc9359377345d8e98\
2070            5dd5f90c78421ffa6efa5eb60428e698c0000000000000000266a24b9e11b6d2f6\
2071            21d7ec3f45a5eca89d3ea6a294cdf3a042e973009584470a12916111e2caa01200\
2072            000000000000000000000000000000000000000000000000000000000000000000\
2073            00000"
2074        )
2075    }
2076
2077    #[test]
2078    fn test_authorization_provider_with_client() {
2079        use std::sync::{Arc, RwLock};
2080
2081        // Track how many times the provider is called
2082        let call_count = Arc::new(RwLock::new(0));
2083        let call_count_clone = call_count.clone();
2084
2085        let auth_provider = Arc::new(move || {
2086            *call_count_clone.write().unwrap() += 1;
2087            Some("Bearer test-token-123".to_string())
2088        });
2089
2090        let client = get_test_auth_client(Some(auth_provider));
2091
2092        // Make a request - provider should be called
2093        let _ = client.server_features();
2094
2095        // Provider should have been called at least once
2096        assert!(*call_count.read().unwrap() >= 1);
2097    }
2098
2099    #[test]
2100    fn test_authorization_provider_dynamic_token_refresh() {
2101        use std::sync::{Arc, RwLock};
2102
2103        // Simulate a token that can be refreshed
2104        let token = Arc::new(RwLock::new("initial-token".to_string()));
2105        let token_clone = token.clone();
2106
2107        let auth_provider: AuthProvider =
2108            Arc::new(move || Some(token_clone.read().unwrap().clone()));
2109
2110        let client = get_test_auth_client(Some(auth_provider.clone()));
2111
2112        // Make first request with initial token
2113        let _ = client.server_features();
2114
2115        // Simulate token refresh
2116        *token.write().unwrap() = "refreshed-token".to_string();
2117
2118        // Make second request - should use the new token
2119        let _ = client.server_features();
2120
2121        // Verify the provider now returns the refreshed token
2122        assert_eq!(auth_provider(), Some("refreshed-token".to_string()));
2123    }
2124
2125    #[test]
2126    fn test_authorization_provider_returns_none() {
2127        use std::sync::Arc;
2128
2129        let auth_provider: AuthProvider = Arc::new(|| None);
2130
2131        let client = get_test_auth_client(Some(auth_provider));
2132
2133        // Should still work when provider returns None
2134        let result = client.server_features();
2135        assert!(result.is_ok());
2136    }
2137
2138    #[test]
2139    fn test_auth_provider_via_constructor() {
2140        use std::sync::Arc;
2141
2142        let auth_provider: AuthProvider = Arc::new(|| Some("Bearer test".to_string()));
2143
2144        let client = get_test_auth_client(Some(auth_provider));
2145
2146        // Verify the provider was set
2147        let result = client.server_features();
2148        assert!(result.is_ok());
2149    }
2150}