imbibe-domain 0.0.1

holds the types related to Block and Tx used throughrout imbibe
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
132
133
134
135
136
137
138
139
140
141
142

use core::fmt::{self, Debug, Formatter};

use bon::Builder;
use bytes::Bytes;
use jiff::Timestamp;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use super::{Address, NonEmptyBz, Sha256};

#[derive(Debug, Clone, Builder)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Block<T = Bytes> {
	header: Header,
	gas_used: u64,
	hash: Sha256,
	data: BlockData<T>,
}

#[derive(Debug, Clone, Builder)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Header {
	chain_id: String,
	height: u64,
	time: Timestamp,
	validators_hash: Sha256,
	next_validators_hash: Sha256,
	consensus_hash: Sha256,
	app_hash: AppHash,
	proposer: Address,
	last_commit_hash: Option<Sha256>,
	data_hash: Option<Sha256>,
	last_results_hash: Option<Sha256>,
	evidence_hash: Option<Sha256>,
}

#[derive(Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct AppHash(Vec<u8>);

#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct BlockData<T>(Vec<NonEmptyBz<T>>);

impl Block {
	pub fn header(&self) -> &Header {
		&self.header
	}

	pub fn data(&self) -> &BlockData<Bytes> {
		&self.data
	}

	pub fn gas_used(&self) -> u64 {
		self.gas_used
	}

	pub fn hash(&self) -> &Sha256 {
		&self.hash
	}
}

impl Header {
	pub fn chain_id(&self) -> &str {
		&self.chain_id
	}

	pub fn height(&self) -> u64 {
		self.height
	}

	pub fn time(&self) -> &Timestamp {
		&self.time
	}

	pub fn validators_hash(&self) -> &Sha256 {
		&self.validators_hash
	}

	pub fn next_validators_hash(&self) -> &Sha256 {
		&self.next_validators_hash
	}

	pub fn consensus_hash(&self) -> &Sha256 {
		&self.consensus_hash
	}

	pub fn app_hash(&self) -> &AppHash {
		&self.app_hash
	}

	pub fn proposer(&self) -> &Address {
		&self.proposer
	}

	pub fn last_commit_hash(&self) -> Option<&Sha256> {
		self.last_commit_hash.as_ref()
	}

	pub fn data_hash(&self) -> Option<&Sha256> {
		self.data_hash.as_ref()
	}

	pub fn last_results_hash(&self) -> Option<&Sha256> {
		self.last_results_hash.as_ref()
	}

	pub fn evidence_hash(&self) -> Option<&Sha256> {
		self.evidence_hash.as_ref()
	}
}

impl AppHash {
	pub const fn new(hash: Vec<u8>) -> Self {
		Self(hash)
	}

	pub fn get(&self) -> &[u8] {
		self.0.as_slice()
	}

	pub fn into_bytes(self) -> Vec<u8> {
		self.0
	}
}

impl<T> BlockData<T> {
	pub fn new(data: Vec<NonEmptyBz<T>>) -> Option<Self> {
		Some(Self(data))
	}

	pub fn get(&self) -> &[NonEmptyBz<T>] {
		&self.0
	}
}

impl Debug for AppHash {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		write!(f, "AppHash({})", const_hex::encode(self.get()))
	}
}