zingolib 0.0.1

Zingo backend library.
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

//! TODO: Add Mod Description Here!

use std::sync::Arc;

use tonic::Request;

use zcash_client_backend::proto::service::{BlockId, ChainSpec, Empty, LightdInfo, RawTransaction};

#[cfg(feature = "test-elevation")]
use zcash_client_backend::proto::service::TreeState;

pub(crate) use zingo_netutils::GrpcConnector;

/// TODO: Add Doc Comment Here!
pub async fn get_info(uri: http::Uri) -> Result<LightdInfo, String> {
    let client = Arc::new(GrpcConnector::new(uri.clone()));

    let mut client = client
        .get_client()
        .await
        .map_err(|e| format!("Error getting client: {:?}", e))?;

    let request = Request::new(Empty {});

    let response = client
        .get_lightd_info(request)
        .await
        .map_err(|e| format!("Error with get_lightd_info response at {uri}: {e:?}"))?;
    Ok(response.into_inner())
}

/// TODO: Add Doc Comment Here!
#[cfg(feature = "test-elevation")]
pub async fn get_trees(uri: http::Uri, height: u64) -> Result<TreeState, String> {
    let client = Arc::new(GrpcConnector::new(uri.clone()));
    let mut client = client
        .get_client()
        .await
        .map_err(|e| format!("Error getting client: {:?}", e))?;

    let b = BlockId {
        height,
        hash: vec![],
    };
    let response = client
        .get_tree_state(Request::new(b))
        .await
        .map_err(|e| format!("Error with get_tree_state response at {uri}: {:?}", e))?;

    Ok(response.into_inner())
}

/// get_latest_block GRPC call
pub async fn get_latest_block(uri: http::Uri) -> Result<BlockId, String> {
    let client = Arc::new(GrpcConnector::new(uri.clone()));
    let mut client = client
        .get_client()
        .await
        .map_err(|e| format!("Error getting client: {:?}", e))?;

    let request = Request::new(ChainSpec {});

    let response = client
        .get_latest_block(request)
        .await
        .map_err(|e| format!("Error with get_latest_block response at {uri}: {:?}", e))?;

    Ok(response.into_inner())
}

/// TODO: Add Doc Comment Here!
pub(crate) async fn send_transaction(
    uri: http::Uri,
    transaction_bytes: Box<[u8]>,
) -> Result<String, String> {
    let client = Arc::new(GrpcConnector::new(uri));
    let mut client = client
        .get_client()
        .await
        .map_err(|e| format!("Error getting client: {:?}", e))?;

    let request = Request::new(RawTransaction {
        data: transaction_bytes.to_vec(),
        height: 0,
    });

    let response = client
        .send_transaction(request)
        .await
        .map_err(|e| format!("Send Error: {}", e))?;

    let sendresponse = response.into_inner();
    if sendresponse.error_code == 0 {
        let mut transaction_id = sendresponse.error_message;
        if transaction_id.starts_with('\"') && transaction_id.ends_with('\"') {
            transaction_id = transaction_id[1..transaction_id.len() - 1].to_string();
        }

        Ok(transaction_id)
    } else {
        Err(format!("Error: {:?}", sendresponse))
    }
}