iota-sdk 0.3.0

The IOTA SDK provides developers with a seamless experience to develop on IOTA by providing account abstractions and clients to interact with node APIs.
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

// Copyright 2021 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

//! The node manager that takes care of sending requests with healthy nodes and quorum if enabled

use std::time::Duration;

use reqwest::RequestBuilder;
use serde::de::DeserializeOwned;
use serde_json::Value;

use crate::client::{
    error::{Error, Result},
    node_manager::node::Node,
};
pub(crate) struct Response(reqwest::Response);

impl Response {
    pub(crate) fn status(&self) -> u16 {
        self.0.status().as_u16()
    }

    pub(crate) async fn into_json<T: DeserializeOwned>(self) -> Result<T> {
        self.0.json().await.map_err(Into::into)
    }

    pub(crate) async fn into_text(self) -> Result<String> {
        self.0.text().await.map_err(Into::into)
    }

    pub(crate) async fn into_bytes(self) -> Result<Vec<u8>> {
        self.0.bytes().await.map(|b| b.to_vec()).map_err(Into::into)
    }
}

#[derive(Clone)]
pub(crate) struct HttpClient {
    client: reqwest::Client,
    user_agent: String,
}

impl HttpClient {
    pub(crate) fn new(user_agent: String) -> Self {
        Self {
            client: reqwest::Client::new(),
            user_agent,
        }
    }

    async fn parse_response(response: reqwest::Response, url: &url::Url) -> Result<Response> {
        let status = response.status();
        if status.is_success() {
            Ok(Response(response))
        } else {
            Err(Error::ResponseError {
                code: status.as_u16(),
                text: response.text().await?,
                url: url.to_string(),
            })
        }
    }

    fn build_request(&self, request_builder: RequestBuilder, node: &Node, _timeout: Duration) -> RequestBuilder {
        let mut request_builder = request_builder.header(reqwest::header::USER_AGENT, &self.user_agent);

        if let Some(node_auth) = &node.auth {
            if let Some(jwt) = &node_auth.jwt {
                request_builder = request_builder.bearer_auth(jwt);
            }
        }
        #[cfg(not(target_family = "wasm"))]
        {
            request_builder = request_builder.timeout(_timeout);
        }
        request_builder
    }

    pub(crate) async fn get(&self, node: Node, timeout: Duration) -> Result<Response> {
        let mut request_builder = self.client.get(node.url.clone());
        request_builder = self.build_request(request_builder, &node, timeout);
        let start_time = instant::Instant::now();
        let resp = request_builder.send().await?;
        log::debug!(
            "GET: {:?} ms for {} {}",
            start_time.elapsed().as_millis(),
            resp.status(),
            node.url
        );
        Self::parse_response(resp, &node.url).await
    }

    // Get with header: "accept", "application/vnd.iota.serializer-v1"
    pub(crate) async fn get_bytes(&self, node: Node, timeout: Duration) -> Result<Response> {
        let mut request_builder = self.client.get(node.url.clone());
        request_builder = self.build_request(request_builder, &node, timeout);
        request_builder = request_builder.header("accept", "application/vnd.iota.serializer-v1");
        let resp = request_builder.send().await?;
        Self::parse_response(resp, &node.url).await
    }

    pub(crate) async fn post_json(&self, node: Node, timeout: Duration, json: Value) -> Result<Response> {
        let mut request_builder = self.client.post(node.url.clone());
        request_builder = self.build_request(request_builder, &node, timeout);
        Self::parse_response(request_builder.json(&json).send().await?, &node.url).await
    }

    pub(crate) async fn post_bytes(&self, node: Node, timeout: Duration, body: &[u8]) -> Result<Response> {
        let mut request_builder = self.client.post(node.url.clone());
        request_builder = self.build_request(request_builder, &node, timeout);
        request_builder = request_builder.header("Content-Type", "application/vnd.iota.serializer-v1");
        Self::parse_response(request_builder.body(body.to_vec()).send().await?, &node.url).await
    }
}