ethos-bitcoind 30.2.11

Generated client for ethos-bitcoind.
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
114
115
116
117

//! control RPC method wrappers
//!
//! This module contains transport wrappers for control methods.

use serde_json::{json, Value};

use crate::transport::core::{TransportError, TransportTrait};

/// Returns an object containing information about memory usage.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.getmemoryinfo(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::getmemoryinfo(&transport, ...).await`
///
/// Calls the `getmemoryinfo` RPC method.
pub async fn get_memory_info(
    transport: &dyn TransportTrait,
    mode: serde_json::Value,
) -> Result<Value, TransportError> {
    let params = vec![json!(mode)];
    let raw = transport.send_request("getmemoryinfo", &params).await?;
    Ok(raw)
}

/// Returns details of the RPC server.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.getrpcinfo(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::getrpcinfo(&transport, ...).await`
///
/// Calls the `getrpcinfo` RPC method.
pub async fn get_rpc_info(transport: &dyn TransportTrait) -> Result<Value, TransportError> {
    let params = Vec::<Value>::new();
    let raw = transport.send_request("getrpcinfo", &params).await?;
    Ok(raw)
}

/// List all commands, or get help for a specified command.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.help(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::help(&transport, ...).await`
///
/// Calls the `help` RPC method.
pub async fn help(
    transport: &dyn TransportTrait,
    command: serde_json::Value,
) -> Result<Value, TransportError> {
    let params = vec![json!(command)];
    let raw = transport.send_request("help", &params).await?;
    Ok(raw)
}

/// Gets and sets the logging configuration.
/// When called without an argument, returns the list of categories with status that are currently being debug logged or not.
/// When called with arguments, adds or removes categories from debug logging and return the lists above.
/// The arguments are evaluated in order "include", "exclude".
/// If an item is both included and excluded, it will thus end up being excluded.
/// The valid logging categories are: addrman, bench, blockstorage, cmpctblock, coindb, estimatefee, http, i2p, ipc, kernel, leveldb, libevent, mempool, mempoolrej, net, privatebroadcast, proxy, prune, qt, rand, reindex, rpc, scan, selectcoins, tor, txpackages, txreconciliation, validation, walletdb, zmq
/// In addition, the following are available as category names with special meanings:
/// - "all",  "1" : represent all logging categories.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.logging(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::logging(&transport, ...).await`
///
/// Calls the `logging` RPC method.
pub async fn logging(
    transport: &dyn TransportTrait,
    include: serde_json::Value,
    exclude: serde_json::Value,
) -> Result<Value, TransportError> {
    let params = vec![json!(include), json!(exclude)];
    let raw = transport.send_request("logging", &params).await?;
    Ok(raw)
}

/// Request a graceful shutdown of Bitcoin Core.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.stop(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::stop(&transport, ...).await`
///
/// Calls the `stop` RPC method.
pub async fn stop(
    transport: &dyn TransportTrait,
    wait: serde_json::Value,
) -> Result<Value, TransportError> {
    let params = vec![json!(wait)];
    let raw = transport.send_request("stop", &params).await?;
    Ok(raw)
}

/// Returns the total uptime of the server.
///
/// # Usage
/// This method can be called using the high-level client interface:
/// - `client.uptime(...).await`
/// Or directly via the transport layer for advanced use cases:
/// - `transport::uptime(&transport, ...).await`
///
/// Calls the `uptime` RPC method.
pub async fn uptime(transport: &dyn TransportTrait) -> Result<Value, TransportError> {
    let params = Vec::<Value>::new();
    let raw = transport.send_request("uptime", &params).await?;
    Ok(raw)
}