vapcore-light 1.12.0

Tetsy Vapory (VapCore) Light Client Implementation (Block Import IO Service, Blockchain Data Fetching, Light Client Header Chain Storage, Tetsy Light Protocol (PLP) Provider, Light Transaction Queue, CHT Definitions, Light Client Data Cache), Tetsy Light Protocol (PLP) Implementation, P2P Network I/O and Event Context Generalization, Peer Error Handling & Punishment, Request Load Timer & Distribution Manager, Pending Request Set Storage, Request Credit Management, Light Client Request Types, Request Chain Builder Utility, On-demand Chain Request Service over LES (for RPCs), ResponseGuard Implementation)
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

// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of Tetsy Vapory.

// Tetsy Vapory is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Tetsy Vapory is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Tetsy Vapory.  If not, see <http://www.gnu.org/licenses/>.

//! Trait for fetching chain data.

use std::sync::Arc;

use common_types::{
	header::Header,
	encoded,
	receipt::Receipt,
};
use enjen::{Engine, StateDependentProof};
use vapory_types::H256;
use futures::future::IntoFuture;

/// Provides full chain data.
pub trait ChainDataFetcher: Send + Sync + 'static {
	/// Error type when data unavailable.
	type Error: ::std::fmt::Debug;

	/// Future for fetching block body.
	type Body: IntoFuture<Item=encoded::Block, Error=Self::Error>;
	/// Future for fetching block receipts.
	type Receipts: IntoFuture<Item=Vec<Receipt>, Error=Self::Error>;
	/// Future for fetching epoch transition
	type Transition: IntoFuture<Item=Vec<u8>, Error=Self::Error>;

	/// Fetch a block body.
	fn block_body(&self, header: &Header) -> Self::Body;

	/// Fetch block receipts.
	fn block_receipts(&self, header: &Header) -> Self::Receipts;

	/// Fetch epoch transition proof at given header.
	fn epoch_transition(
		&self,
		_hash: H256,
		_engine: Arc<dyn Engine>,
		_checker: Arc<dyn StateDependentProof>
	) -> Self::Transition;
}

/// Fetcher implementation which cannot fetch anything.
pub struct Unavailable;

/// Create a fetcher which has all data unavailable.
pub fn unavailable() -> Unavailable { Unavailable }

impl ChainDataFetcher for Unavailable {
	type Error = &'static str;

	type Body = Result<encoded::Block, &'static str>;
	type Receipts = Result<Vec<Receipt>, &'static str>;
	type Transition = Result<Vec<u8>, &'static str>;

	fn block_body(&self, _header: &Header) -> Self::Body {
		Err("fetching block bodies unavailable")
	}

	fn block_receipts(&self, _header: &Header) -> Self::Receipts {
		Err("fetching block receipts unavailable")
	}

	fn epoch_transition(
		&self,
		_hash: H256,
		_engine: Arc<dyn Engine>,
		_checker: Arc<dyn StateDependentProof>
	) -> Self::Transition {
		Err("fetching epoch transition proofs unavailable")
	}
}