avalanche-types 0.1.5

Avalanche primitive types in Rust
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

//! Avalanche Admin RPC API endpoints.
use std::time::Duration;

use reqwest::{header::CONTENT_TYPE, ClientBuilder};

use crate::{
    errors::{Error, Result},
    jsonrpc::admin::{ChainAliasParams, ChainAliasRequest, ChainAliasResponse},
    jsonrpc::client::url,
    utils,
};

/// Set an alias for a chain.
pub async fn alias_chain(
    http_rpc: &str,
    chain: String,
    alias: String,
) -> Result<ChainAliasResponse> {
    let (scheme, host, port, _, _) =
        utils::urls::extract_scheme_host_port_path_chain_alias(http_rpc).map_err(|e| {
            Error::Other {
                message: format!("failed extract_scheme_host_port_path_chain_alias '{}'", e),
                retryable: false,
            }
        })?;

    let url = url::try_create_url(url::Path::Admin, scheme.as_deref(), host.as_str(), port)?;
    log::info!("getting network name for {url}");

    let data = ChainAliasRequest {
        params: Some(ChainAliasParams { chain, alias }),
        ..Default::default()
    };

    let d = data.encode_json().map_err(|e| Error::Other {
        message: format!("failed encode_json '{}'", e),
        retryable: false,
    })?;

    let req_cli_builder = ClientBuilder::new()
        .user_agent(env!("CARGO_PKG_NAME"))
        .danger_accept_invalid_certs(true)
        .timeout(Duration::from_secs(15))
        .connection_verbose(true)
        .build()
        .map_err(|e| {
            // TODO: check retryable
            Error::Other {
                message: format!("failed reqwest::ClientBuilder.build '{}'", e),
                retryable: false,
            }
        })?;

    let resp = req_cli_builder
        .post(url.to_string())
        .header(CONTENT_TYPE, "application/json")
        .body(d)
        .send()
        .await
        .map_err(|e|
        // TODO: check retryable
        Error::API {
            message: format!("failed reqwest::Client.send '{}'", e),
            retryable: false,
        })?;

    let out = resp.bytes().await.map_err(|e| {
        // TODO: check retryable
        Error::Other {
            message: format!("failed reqwest response bytes '{}'", e),
            retryable: false,
        }
    })?;

    let response: ChainAliasResponse = serde_json::from_slice(out.as_ref())
        .map_err(|e| Error::Other {
            message: format!("failed serde_json::from_slice '{}'", e),
            retryable: false,
        })
        .unwrap();

    Ok(response)
}