pink_subrpc/
objects.rs

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// TODO: handle the failure case
101#[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/// Wraps an already encoded byte vector, prevents being encoded as a raw byte vector as part of
123/// the transaction payload
124#[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}