pink-subrpc 0.8.0

A substrate rpc client running in pink.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use alloc::borrow::ToOwned;
use alloc::string::String;
use alloc::vec::Vec;
use scale::{Decode, Encode};
use serde::Deserialize;

#[allow(dead_code)]
#[derive(Deserialize, Debug)]
pub struct BlockHeader<'a> {
    pub(crate) jsonrpc: &'a str,
    #[serde(borrow)]
    pub(crate) result: BlockHeaderResult<'a>,
    pub(crate) id: u32,
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct BlockHeaderResult<'a> {
    #[serde(alias = "parentHash")]
    pub(crate) parent_hash: &'a str,
    pub(crate) number: &'a str,
    #[serde(alias = "stateRoot")]
    pub(crate) state_root: &'a str,
    #[serde(alias = "extrinsicsRoot")]
    pub(crate) extrinsics_root: &'a str,
}

#[derive(Encode, Decode, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
pub struct BlockHeaderOk {
    pub(crate) parent_hash: [u8; 32],
    #[codec(compact)]
    pub(crate) number: u32,
    pub(crate) state_root: [u8; 32],
    pub(crate) extrinsics_root: [u8; 32],
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct NextNonce<'a> {
    jsonrpc: &'a str,
    pub(crate) result: u64,
    id: u32,
}

#[derive(Encode, Decode, Clone, Debug)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
pub struct NextNonceOk {
    pub(crate) next_nonce: u64,
}

#[allow(dead_code)]
#[derive(Deserialize, Debug)]
pub struct RuntimeVersion<'a> {
    pub(crate) jsonrpc: &'a str,
    #[serde(borrow)]
    pub(crate) result: RuntimeVersionResult<'a>,
    pub(crate) id: u32,
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
#[serde(bound(deserialize = "alloc::vec::Vec<(&'a str, u32)>: Deserialize<'de>"))]
pub struct RuntimeVersionResult<'a> {
    #[serde(alias = "specName")]
    pub(crate) spec_name: &'a str,
    #[serde(alias = "implName")]
    pub(crate) impl_name: &'a str,
    #[serde(alias = "authoringVersion")]
    pub(crate) authoring_version: u32,
    #[serde(alias = "specVersion")]
    pub(crate) spec_version: u32,
    #[serde(alias = "implVersion")]
    pub(crate) impl_version: u32,
    #[serde(borrow)]
    pub(crate) apis: Vec<(&'a str, u32)>,
    #[serde(alias = "transactionVersion")]
    pub(crate) transaction_version: u32,
    #[serde(alias = "stateVersion")]
    pub(crate) state_version: u32,
}

#[derive(Encode, Decode, Clone, Debug, PartialEq)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
pub struct RuntimeVersionOk {
    pub(crate) spec_name: String,
    pub(crate) impl_name: String,
    pub(crate) authoring_version: u32,
    pub(crate) spec_version: u32,
    pub(crate) impl_version: u32,
    pub(crate) apis: Vec<(String, u32)>,
    pub(crate) transaction_version: u32,
    pub(crate) state_version: u32,
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct GenesisHash<'a> {
    pub(crate) jsonrpc: &'a str,
    pub(crate) result: &'a str,
    pub(crate) id: u32,
}

// TODO: handle the failure case
#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct TransactionResponse<'a> {
    pub(crate) jsonrpc: &'a str,
    pub(crate) result: &'a str,
    pub(crate) id: u32,
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct GetStorageResponse<'a> {
    pub(crate) jsonrpc: &'a str,
    pub(crate) result: Option<&'a str>,
    pub(crate) id: u32,
}

#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
pub struct QueryContractResponse<'a> {
    pub(crate) jsonrpc: &'a str,
    pub(crate) result: Option<&'a str>,
    pub(crate) id: u32,
}

/// Wraps an already encoded byte vector, prevents being encoded as a raw byte vector as part of
/// the transaction payload
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Encoded(pub Vec<u8>);

impl scale::Encode for Encoded {
    fn encode(&self) -> Vec<u8> {
        self.0.to_owned()
    }
}