urma-runtime 0.3.1

URMA publication planning, network transports and recovery
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#[cfg(not(target_arch = "wasm32"))]
use crate::electrum::Electrum;
use crate::endpoints::PublicEndpoint;
use crate::error::Error;
use crate::light::LightSync;
#[cfg(not(target_arch = "wasm32"))]
use crate::p2p::P2pProvider;
#[cfg(not(target_arch = "wasm32"))]
use crate::pinning::Pins;
use crate::remote::Remote;
use crate::transport::Provider;
#[cfg(not(target_arch = "wasm32"))]
use std::path::Path;
#[cfg(not(target_arch = "wasm32"))]
use std::sync::Arc;
use urma_chain::observation::Chain;

pub enum LightClient {
    Absent,
    #[cfg(not(target_arch = "wasm32"))]
    P2p(Arc<P2pProvider>),
}

impl LightClient {
    pub(crate) fn providers(&self) -> Vec<Box<dyn Provider>> {
        match self {
            Self::Absent => Vec::new(),
            #[cfg(not(target_arch = "wasm32"))]
            Self::P2p(provider) => vec![Box::new(provider.clone())],
        }
    }

    pub(crate) fn state(&self) -> LightSync {
        match self {
            Self::Absent => LightSync::Absent,
            #[cfg(not(target_arch = "wasm32"))]
            Self::P2p(provider) => provider.state(),
        }
    }

    pub(crate) fn warm(&self) -> Result<(), Error> {
        match self {
            Self::Absent => {
                tracing::debug!("no light client to warm");
                Ok(())
            }
            #[cfg(not(target_arch = "wasm32"))]
            Self::P2p(provider) => provider.warm(),
        }
    }
}

#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn light_clients(chain: Chain, cache_dir: &Path) -> Result<LightClient, Error> {
    match chain {
        Chain::LitecoinMainnet | Chain::LitecoinTestnet => Ok(LightClient::P2p(Arc::new(
            P2pProvider::new(chain, cache_dir)?,
        ))),
        Chain::BitcoinMainnet | Chain::BitcoinRegtest | Chain::BitcoinTestnet4 => {
            tracing::debug!(
                ?chain,
                "no light client provider for this chain; reads start at public providers"
            );
            Ok(LightClient::Absent)
        }
    }
}

#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn assemble(
    endpoints: Vec<PublicEndpoint>,
    pins: Arc<Pins>,
    light: &LightClient,
) -> Result<Vec<Box<dyn Provider>>, Error> {
    let mut providers = light.providers();
    for endpoint in endpoints {
        let provider: Box<dyn Provider> = match endpoint {
            PublicEndpoint::Electrum(_) => Box::new(Electrum::new(endpoint, pins.clone())?),
            PublicEndpoint::Rpc(_) | PublicEndpoint::Esplora(_) => Box::new(Remote::new(endpoint)?),
        };
        providers.push(provider);
    }
    Ok(providers)
}

#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn ephemeral(
    chain: Chain,
    endpoints: Vec<PublicEndpoint>,
) -> Result<Vec<Box<dyn Provider>>, Error> {
    tracing::debug!(
        ?chain,
        "ephemeral public node has no cache directory; no light client"
    );
    assemble(endpoints, Arc::new(Pins::ephemeral()), &LightClient::Absent)
}

#[cfg(target_arch = "wasm32")]
pub(crate) fn ephemeral(
    chain: Chain,
    endpoints: Vec<PublicEndpoint>,
) -> Result<Vec<Box<dyn Provider>>, Error> {
    tracing::debug!(?chain, "no light client provider on WASM");
    let mut providers = LightClient::Absent.providers();
    for endpoint in endpoints {
        let provider: Box<dyn Provider> = match endpoint {
            PublicEndpoint::Electrum(url) => {
                return Err(Error::Unsupported(format!(
                    "electrum endpoint {url} needs a TCP socket, unavailable on WASM"
                )));
            }
            PublicEndpoint::Rpc(_) | PublicEndpoint::Esplora(_) => Box::new(Remote::new(endpoint)?),
        };
        providers.push(provider);
    }
    Ok(providers)
}