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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use multiaddr::Multiaddr;
use std::error::Error;
use tofuri_api_internal_core::Data;
use tofuri_api_internal_core::Request;
use tofuri_block::BlockA;
use tofuri_core::*;
use tofuri_stake::StakeA;
use tofuri_stake::StakeB;
use tofuri_transaction::TransactionA;
use tofuri_transaction::TransactionB;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
async fn r(data: Data, addr: &str, vec: Option<Vec<u8>>) -> Result<Vec<u8>, Box<dyn Error>> {
    let mut stream = TcpStream::connect(addr).await?;
    let request = Request {
        data,
        vec: vec.unwrap_or(vec![]),
    };
    stream.write_all(&bincode::serialize(&request)?).await?;
    let mut buf = [0; 1024];
    let bytes = stream.read(&mut buf).await?;
    let vec = buf[..bytes].to_vec();
    Ok(vec)
}
pub async fn balance(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Balance, addr, Some(bincode::serialize(address_bytes)?)).await?)?)
}
pub async fn balance_pending_min(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(
        &r(Data::BalancePendingMin, addr, Some(bincode::serialize(address_bytes)?)).await?,
    )?)
}
pub async fn balance_pending_max(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(
        &r(Data::BalancePendingMax, addr, Some(bincode::serialize(address_bytes)?)).await?,
    )?)
}
pub async fn staked(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Staked, addr, Some(bincode::serialize(address_bytes)?)).await?)?)
}
pub async fn staked_pending_min(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(
        &r(Data::StakedPendingMin, addr, Some(bincode::serialize(address_bytes)?)).await?,
    )?)
}
pub async fn staked_pending_max(addr: &str, address_bytes: &AddressBytes) -> Result<u128, Box<dyn Error>> {
    Ok(bincode::deserialize(
        &r(Data::StakedPendingMax, addr, Some(bincode::serialize(address_bytes)?)).await?,
    )?)
}
pub async fn height(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Height, addr, None).await?)?)
}
pub async fn height_by_hash(addr: &str, hash: &Hash) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::HeightByHash, addr, Some(bincode::serialize(hash)?)).await?)?)
}
pub async fn block_latest(addr: &str) -> Result<BlockA, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::BlockLatest, addr, None).await?)?)
}
pub async fn hash_by_height(addr: &str, height: &usize) -> Result<Hash, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::HashByHeight, addr, Some(bincode::serialize(height)?)).await?)?)
}
pub async fn block_by_hash(addr: &str, hash: &Hash) -> Result<BlockA, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::BlockByHash, addr, Some(bincode::serialize(hash)?)).await?)?)
}
pub async fn transaction_by_hash(addr: &str, hash: &Hash) -> Result<TransactionA, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::TransactionByHash, addr, Some(bincode::serialize(hash)?)).await?)?)
}
pub async fn stake_by_hash(addr: &str, hash: &Hash) -> Result<StakeA, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::StakeByHash, addr, Some(bincode::serialize(hash)?)).await?)?)
}
pub async fn peers(addr: &str) -> Result<Vec<Multiaddr>, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Peers, addr, None).await?)?)
}
pub async fn peer(addr: &str, multiaddr: &Multiaddr) -> Result<(), Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Peer, addr, Some(bincode::serialize(multiaddr)?)).await?)?)
}
pub async fn transaction(addr: &str, transaction_b: &TransactionB) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(
        &r(Data::Transaction, addr, Some(bincode::serialize(transaction_b)?)).await?,
    )?)
}
pub async fn stake(addr: &str, stake_b: &StakeB) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Stake, addr, Some(bincode::serialize(stake_b)?)).await?)?)
}
pub async fn cargo_pkg_name(addr: &str) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::CargoPkgName, addr, None).await?)?)
}
pub async fn cargo_pkg_version(addr: &str) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::CargoPkgVersion, addr, None).await?)?)
}
pub async fn cargo_pkg_repository(addr: &str) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::CargoPkgRepository, addr, None).await?)?)
}
pub async fn git_hash(addr: &str) -> Result<String, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::GitHash, addr, None).await?)?)
}
pub async fn address(addr: &str) -> Result<AddressBytes, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Address, addr, None).await?)?)
}
pub async fn ticks(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Ticks, addr, None).await?)?)
}
pub async fn lag(addr: &str) -> Result<f64, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Lag, addr, None).await?)?)
}
pub async fn time(addr: &str) -> Result<i64, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Time, addr, None).await?)?)
}
pub async fn tree_size(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::TreeSize, addr, None).await?)?)
}
pub async fn sync(addr: &str) -> Result<tofuri_blockchain::sync::Sync, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::Sync, addr, None).await?)?)
}
pub async fn random_queue(addr: &str) -> Result<Vec<AddressBytes>, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::RandomQueue, addr, None).await?)?)
}
pub async fn dynamic_hashes(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::DynamicHashes, addr, None).await?)?)
}
pub async fn dynamic_latest_hashes(addr: &str) -> Result<Vec<Hash>, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::DynamicLatestHashes, addr, None).await?)?)
}
pub async fn dynamic_stakers(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::DynamicStakers, addr, None).await?)?)
}
pub async fn trusted_hashes(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::TrustedHashes, addr, None).await?)?)
}
pub async fn trusted_latest_hashes(addr: &str) -> Result<Vec<Hash>, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::TrustedLatestHashes, addr, None).await?)?)
}
pub async fn trusted_stakers(addr: &str) -> Result<usize, Box<dyn Error>> {
    Ok(bincode::deserialize(&r(Data::TrustedStakers, addr, None).await?)?)
}