sp_runtime/generic/
block.rs1#[cfg(feature = "std")]
21use std::fmt;
22
23#[cfg(feature = "serde")]
24use serde::{Deserialize, Serialize};
25
26use crate::{
27 codec::{Codec, Decode, Encode},
28 traits::{
29 self, Block as BlockT, Header as HeaderT, MaybeSerialize, MaybeSerializeDeserialize,
30 Member, NumberFor,
31 },
32 Justifications,
33};
34use alloc::vec::Vec;
35use sp_core::RuntimeDebug;
36
37#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
39pub enum BlockId<Block: BlockT> {
40 Hash(Block::Hash),
42 Number(NumberFor<Block>),
44}
45
46impl<Block: BlockT> BlockId<Block> {
47 pub const fn hash(hash: Block::Hash) -> Self {
49 BlockId::Hash(hash)
50 }
51
52 pub const fn number(number: NumberFor<Block>) -> Self {
54 BlockId::Number(number)
55 }
56
57 pub fn is_pre_genesis(&self) -> bool {
59 match self {
60 BlockId::Hash(hash) => hash == &Default::default(),
61 BlockId::Number(_) => false,
62 }
63 }
64
65 pub fn pre_genesis() -> Self {
67 BlockId::Hash(Default::default())
68 }
69}
70
71impl<Block: BlockT> Copy for BlockId<Block> {}
72
73#[cfg(feature = "std")]
74impl<Block: BlockT> fmt::Display for BlockId<Block> {
75 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
76 write!(f, "{:?}", self)
77 }
78}
79
80#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)]
82#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
83#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
84#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
85pub struct Block<Header, Extrinsic> {
86 pub header: Header,
88 pub extrinsics: Vec<Extrinsic>,
90}
91
92impl<Header, Extrinsic> traits::HeaderProvider for Block<Header, Extrinsic>
93where
94 Header: HeaderT,
95{
96 type HeaderT = Header;
97}
98
99impl<Header, Extrinsic: MaybeSerialize> traits::Block for Block<Header, Extrinsic>
100where
101 Header: HeaderT + MaybeSerializeDeserialize,
102 Extrinsic: Member + Codec + traits::ExtrinsicLike,
103{
104 type Extrinsic = Extrinsic;
105 type Header = Header;
106 type Hash = <Self::Header as traits::Header>::Hash;
107
108 fn header(&self) -> &Self::Header {
109 &self.header
110 }
111 fn extrinsics(&self) -> &[Self::Extrinsic] {
112 &self.extrinsics[..]
113 }
114 fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>) {
115 (self.header, self.extrinsics)
116 }
117 fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
118 Block { header, extrinsics }
119 }
120 fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8> {
121 (header, extrinsics).encode()
122 }
123}
124
125#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
127#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
128#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
129#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
130pub struct SignedBlock<Block> {
131 pub block: Block,
133 pub justifications: Option<Justifications>,
135}