subxt 0.50.0

Interact with Substrate based chains on the Polkadot Network
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

// Copyright 2019-2026 Parity Technologies (UK) Ltd.
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
// see LICENSE for license details.

use serde_json::value::RawValue;

/// Possible errors encountered trying to fetch a chain spec from an RPC node.
#[derive(thiserror::Error, Debug)]
#[allow(missing_docs)]
pub enum FetchChainspecError {
    #[error("Cannot fetch chain spec: RPC error: {0}.")]
    RpcError(String),
    #[error("Cannot fetch chain spec: Invalid URL.")]
    InvalidUrl,
    #[error("Cannot fetch chain spec: Invalid URL scheme.")]
    InvalidScheme,
    #[error("Cannot fetch chain spec: Handshake error establishing WS connection.")]
    HandshakeError,
}

/// Fetch a chain spec from an RPC node at the given URL.
pub async fn fetch_chainspec_from_rpc_node(
    url: impl AsRef<str>,
) -> Result<Box<RawValue>, FetchChainspecError> {
    use jsonrpsee::core::client::{ClientT, SubscriptionClientT};
    use jsonrpsee::rpc_params;

    let client = jsonrpsee_helpers::client(url.as_ref()).await?;

    let result = client
        .request("sync_state_genSyncSpec", jsonrpsee::rpc_params![true])
        .await
        .map_err(|err| FetchChainspecError::RpcError(err.to_string()))?;

    // Subscribe to the finalized heads of the chain.
    let mut subscription = SubscriptionClientT::subscribe::<Box<RawValue>, _>(
        &client,
        "chain_subscribeFinalizedHeads",
        rpc_params![],
        "chain_unsubscribeFinalizedHeads",
    )
    .await
    .map_err(|err| FetchChainspecError::RpcError(err.to_string()))?;

    // We must ensure that the finalized block of the chain is not the block included
    // in the chainSpec.
    // This is a temporary workaround for: https://github.com/smol-dot/smoldot/issues/1562.
    // The first finalized block that is received might by the finalized block could be the one
    // included in the chainSpec. Decoding the chainSpec for this purpose is too complex.
    let _ = subscription.next().await;
    let _ = subscription.next().await;

    Ok(result)
}

#[cfg(all(feature = "jsonrpsee", feature = "native"))]
mod jsonrpsee_helpers {
    use super::FetchChainspecError;
    use tokio_util::compat::Compat;

    pub use jsonrpsee::{
        client_transport::ws::{self, EitherStream, Url, WsTransportClientBuilder},
        core::client::Client,
    };

    pub type Sender = ws::Sender<Compat<EitherStream>>;
    pub type Receiver = ws::Receiver<Compat<EitherStream>>;

    /// Build WS RPC client from URL
    pub async fn client(url: &str) -> Result<Client, FetchChainspecError> {
        let url = Url::parse(url).map_err(|_| FetchChainspecError::InvalidUrl)?;

        if url.scheme() != "ws" && url.scheme() != "wss" {
            return Err(FetchChainspecError::InvalidScheme);
        }

        let (sender, receiver) = ws_transport(url).await?;

        Ok(Client::builder()
            .max_buffer_capacity_per_subscription(4096)
            .build_with_tokio(sender, receiver))
    }

    async fn ws_transport(url: Url) -> Result<(Sender, Receiver), FetchChainspecError> {
        WsTransportClientBuilder::default()
            .build(url)
            .await
            .map_err(|_| FetchChainspecError::HandshakeError)
    }
}

#[cfg(all(feature = "jsonrpsee", feature = "web"))]
mod jsonrpsee_helpers {
    use super::FetchChainspecError;
    pub use jsonrpsee::{
        client_transport::web,
        core::client::{Client, ClientBuilder},
    };

    /// Build web RPC client from URL
    pub async fn client(url: &str) -> Result<Client, FetchChainspecError> {
        let (sender, receiver) = web::connect(url)
            .await
            .map_err(|_| FetchChainspecError::HandshakeError)?;

        Ok(ClientBuilder::default()
            .max_buffer_capacity_per_subscription(4096)
            .build_with_wasm(sender, receiver))
    }
}