1use 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
41pub const CLIENT_NAME: &str = "";
43
44pub const PROTOCOL_VERSION_MIN: &str = "1.4";
46
47pub const PROTOCOL_VERSION_MAX: &str = "1.6";
49
50fn 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
87pub trait ToSocketAddrsDomain: ToSocketAddrs {
91 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
132pub 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 protocol_version: Mutex<Option<String>>,
159
160 auth_provider: Option<AuthProvider>,
162
163 calls: AtomicUsize,
164}
165
166impl<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
213pub type ElectrumPlaintextStream = TcpStream;
215impl RawClient<ElectrumPlaintextStream> {
216 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 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")]
281pub type ElectrumSslStream = SslStream<TcpStream>;
283#[cfg(feature = "openssl")]
284impl RawClient<ElectrumSslStream> {
285 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 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 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))]
406pub type ElectrumSslStream = StreamOwned<ClientConnection, TcpStream>;
408#[cfg(all(
409 any(feature = "rustls", feature = "rustls-ring"),
410 not(feature = "openssl")
411))]
412impl RawClient<ElectrumSslStream> {
413 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 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 #[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 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")]
527pub type ElectrumProxyStream = Socks5Stream;
529#[cfg(feature = "proxy")]
530impl RawClient<ElectrumProxyStream> {
531 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 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 fn with_auth(mut self, auth_provider: Option<AuthProvider>) -> Self {
628 self.auth_provider = auth_provider;
629 self
630 }
631
632 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 self.waiting_map.lock()?.get(&until_message).is_none() {
688 return Err(Error::CouldntLockReader);
689 }
690 }
691
692 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 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 trace!(
728 "Reader thread {} received a response for its request",
729 resp_id
730 );
731
732 let mut map = self.waiting_map.lock()?;
734 map.remove(&resp_id);
735
736 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 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 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 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 let (sender, receiver) = channel();
797 self.waiting_map.lock()?.insert(req.id, sender);
798
799 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); self.increment_calls();
817
818 let mut resp = match self.recv(&receiver, req.id) {
819 Ok(resp) => resp,
820 e @ Err(_) => {
821 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 match self._reader_thread(Some(req_id)) {
839 Ok(response) => break Ok(response),
840 Err(Error::CouldntLockReader) => {
841 match receiver.recv()? {
842 ChannelMessage::Response(received) => break Ok(received),
844 ChannelMessage::WakeUp => {
845 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 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 if idx == 0 {
940 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 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); 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 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 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 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 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 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 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 let resp = client.transaction_broadcast_package_raw::<Vec<u8>>(&[]);
1630 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 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 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 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 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 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 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 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 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 let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF")
2030 .unwrap()
2031 .assume_checked();
2032
2033 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 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 let _ = client.server_features();
2094
2095 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 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 let _ = client.server_features();
2114
2115 *token.write().unwrap() = "refreshed-token".to_string();
2117
2118 let _ = client.server_features();
2120
2121 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 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 let result = client.server_features();
2148 assert!(result.is_ok());
2149 }
2150}