1use alloc::borrow::ToOwned;
2use alloc::string::String;
3use alloc::vec::Vec;
4use scale::{Decode, Encode};
5use serde::Deserialize;
6
7#[allow(dead_code)]
8#[derive(Deserialize, Debug)]
9pub struct BlockHeader<'a> {
10 pub(crate) jsonrpc: &'a str,
11 #[serde(borrow)]
12 pub(crate) result: BlockHeaderResult<'a>,
13 pub(crate) id: u32,
14}
15
16#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
17pub struct BlockHeaderResult<'a> {
18 #[serde(alias = "parentHash")]
19 pub(crate) parent_hash: &'a str,
20 pub(crate) number: &'a str,
21 #[serde(alias = "stateRoot")]
22 pub(crate) state_root: &'a str,
23 #[serde(alias = "extrinsicsRoot")]
24 pub(crate) extrinsics_root: &'a str,
25}
26
27#[derive(Encode, Decode, Clone, Debug, PartialEq)]
28#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
29pub struct BlockHeaderOk {
30 pub(crate) parent_hash: [u8; 32],
31 #[codec(compact)]
32 pub(crate) number: u32,
33 pub(crate) state_root: [u8; 32],
34 pub(crate) extrinsics_root: [u8; 32],
35}
36
37#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
38pub struct NextNonce<'a> {
39 jsonrpc: &'a str,
40 pub(crate) result: u64,
41 id: u32,
42}
43
44#[derive(Encode, Decode, Clone, Debug)]
45#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
46pub struct NextNonceOk {
47 pub(crate) next_nonce: u64,
48}
49
50#[allow(dead_code)]
51#[derive(Deserialize, Debug)]
52pub struct RuntimeVersion<'a> {
53 pub(crate) jsonrpc: &'a str,
54 #[serde(borrow)]
55 pub(crate) result: RuntimeVersionResult<'a>,
56 pub(crate) id: u32,
57}
58
59#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
60#[serde(bound(deserialize = "alloc::vec::Vec<(&'a str, u32)>: Deserialize<'de>"))]
61pub struct RuntimeVersionResult<'a> {
62 #[serde(alias = "specName")]
63 pub(crate) spec_name: &'a str,
64 #[serde(alias = "implName")]
65 pub(crate) impl_name: &'a str,
66 #[serde(alias = "authoringVersion")]
67 pub(crate) authoring_version: u32,
68 #[serde(alias = "specVersion")]
69 pub(crate) spec_version: u32,
70 #[serde(alias = "implVersion")]
71 pub(crate) impl_version: u32,
72 #[serde(borrow)]
73 pub(crate) apis: Vec<(&'a str, u32)>,
74 #[serde(alias = "transactionVersion")]
75 pub(crate) transaction_version: u32,
76 #[serde(alias = "stateVersion")]
77 pub(crate) state_version: u32,
78}
79
80#[derive(Encode, Decode, Clone, Debug, PartialEq)]
81#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
82pub struct RuntimeVersionOk {
83 pub(crate) spec_name: String,
84 pub(crate) impl_name: String,
85 pub(crate) authoring_version: u32,
86 pub(crate) spec_version: u32,
87 pub(crate) impl_version: u32,
88 pub(crate) apis: Vec<(String, u32)>,
89 pub(crate) transaction_version: u32,
90 pub(crate) state_version: u32,
91}
92
93#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
94pub struct GenesisHash<'a> {
95 pub(crate) jsonrpc: &'a str,
96 pub(crate) result: &'a str,
97 pub(crate) id: u32,
98}
99
100#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
102pub struct TransactionResponse<'a> {
103 pub(crate) jsonrpc: &'a str,
104 pub(crate) result: &'a str,
105 pub(crate) id: u32,
106}
107
108#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
109pub struct GetStorageResponse<'a> {
110 pub(crate) jsonrpc: &'a str,
111 pub(crate) result: Option<&'a str>,
112 pub(crate) id: u32,
113}
114
115#[derive(Deserialize, Encode, Clone, Debug, PartialEq)]
116pub struct QueryContractResponse<'a> {
117 pub(crate) jsonrpc: &'a str,
118 pub(crate) result: Option<&'a str>,
119 pub(crate) id: u32,
120}
121
122#[derive(Clone, Debug, Eq, PartialEq)]
125pub struct Encoded(pub Vec<u8>);
126
127impl scale::Encode for Encoded {
128 fn encode(&self) -> Vec<u8> {
129 self.0.to_owned()
130 }
131}