198 lines
5.6 KiB
Rust
198 lines
5.6 KiB
Rust
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity.
|
|
|
|
// Parity 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.
|
|
|
|
// Parity 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 Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! LES request types.
|
|
|
|
use util::H256;
|
|
|
|
/// Either a hash or a number.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub enum HashOrNumber {
|
|
/// Block hash variant.
|
|
Hash(H256),
|
|
/// Block number variant.
|
|
Number(u64),
|
|
}
|
|
|
|
impl From<H256> for HashOrNumber {
|
|
fn from(hash: H256) -> Self {
|
|
HashOrNumber::Hash(hash)
|
|
}
|
|
}
|
|
|
|
impl From<u64> for HashOrNumber {
|
|
fn from(num: u64) -> Self {
|
|
HashOrNumber::Number(num)
|
|
}
|
|
}
|
|
|
|
/// A request for block headers.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct Headers {
|
|
/// Starting block number or hash.
|
|
pub start: HashOrNumber,
|
|
/// The maximum amount of headers which can be returned.
|
|
pub max: usize,
|
|
/// The amount of headers to skip between each response entry.
|
|
pub skip: u64,
|
|
/// Whether the headers should proceed in falling number from the initial block.
|
|
pub reverse: bool,
|
|
}
|
|
|
|
/// A request for specific block bodies.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct Bodies {
|
|
/// Hashes which bodies are being requested for.
|
|
pub block_hashes: Vec<H256>
|
|
}
|
|
|
|
/// A request for transaction receipts.
|
|
///
|
|
/// This request is answered with a list of transaction receipts for each block
|
|
/// requested.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct Receipts {
|
|
/// Block hashes to return receipts for.
|
|
pub block_hashes: Vec<H256>,
|
|
}
|
|
|
|
/// A request for a state proof
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct StateProof {
|
|
/// Block hash to query state from.
|
|
pub block: H256,
|
|
/// Key of the state trie -- corresponds to account hash.
|
|
pub key1: H256,
|
|
/// Key in that account's storage trie; if empty, then the account RLP should be
|
|
/// returned.
|
|
pub key2: Option<H256>,
|
|
/// if greater than zero, trie nodes beyond this level may be omitted.
|
|
pub from_level: u32, // could even safely be u8; trie w/ 32-byte key can be at most 64-levels deep.
|
|
}
|
|
|
|
/// A request for state proofs.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct StateProofs {
|
|
/// All the proof requests.
|
|
pub requests: Vec<StateProof>,
|
|
}
|
|
|
|
/// A request for contract code.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct ContractCode {
|
|
/// Block hash
|
|
pub block_hash: H256,
|
|
/// Account key (== sha3(address))
|
|
pub account_key: H256,
|
|
}
|
|
|
|
/// A request for contract code.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct ContractCodes {
|
|
/// Block hash and account key (== sha3(address)) pairs to fetch code for.
|
|
pub code_requests: Vec<ContractCode>,
|
|
}
|
|
|
|
/// A request for a header proof from the Canonical Hash Trie.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct HeaderProof {
|
|
/// Number of the CHT.
|
|
pub cht_number: u64,
|
|
/// Block number requested. May not be 0: genesis isn't included in any CHT.
|
|
pub block_number: u64,
|
|
/// If greater than zero, trie nodes beyond this level may be omitted.
|
|
pub from_level: u32,
|
|
}
|
|
|
|
/// A request for header proofs from the CHT.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub struct HeaderProofs {
|
|
/// All the proof requests.
|
|
pub requests: Vec<HeaderProof>,
|
|
}
|
|
|
|
/// Kinds of requests.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub enum Kind {
|
|
/// Requesting headers.
|
|
Headers,
|
|
/// Requesting block bodies.
|
|
Bodies,
|
|
/// Requesting transaction receipts.
|
|
Receipts,
|
|
/// Requesting proofs of state trie nodes.
|
|
StateProofs,
|
|
/// Requesting contract code by hash.
|
|
Codes,
|
|
/// Requesting header proofs (from the CHT).
|
|
HeaderProofs,
|
|
}
|
|
|
|
/// Encompasses all possible types of requests in a single structure.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
#[cfg_attr(feature = "ipc", binary)]
|
|
pub enum Request {
|
|
/// Requesting headers.
|
|
Headers(Headers),
|
|
/// Requesting block bodies.
|
|
Bodies(Bodies),
|
|
/// Requesting transaction receipts.
|
|
Receipts(Receipts),
|
|
/// Requesting state proofs.
|
|
StateProofs(StateProofs),
|
|
/// Requesting contract codes.
|
|
Codes(ContractCodes),
|
|
/// Requesting header proofs.
|
|
HeaderProofs(HeaderProofs),
|
|
}
|
|
|
|
impl Request {
|
|
/// Get the kind of request this is.
|
|
pub fn kind(&self) -> Kind {
|
|
match *self {
|
|
Request::Headers(_) => Kind::Headers,
|
|
Request::Bodies(_) => Kind::Bodies,
|
|
Request::Receipts(_) => Kind::Receipts,
|
|
Request::StateProofs(_) => Kind::StateProofs,
|
|
Request::Codes(_) => Kind::Codes,
|
|
Request::HeaderProofs(_) => Kind::HeaderProofs,
|
|
}
|
|
}
|
|
|
|
/// Get the amount of requests being made.
|
|
pub fn amount(&self) -> usize {
|
|
match *self {
|
|
Request::Headers(ref req) => req.max,
|
|
Request::Bodies(ref req) => req.block_hashes.len(),
|
|
Request::Receipts(ref req) => req.block_hashes.len(),
|
|
Request::StateProofs(ref req) => req.requests.len(),
|
|
Request::Codes(ref req) => req.code_requests.len(),
|
|
Request::HeaderProofs(ref req) => req.requests.len(),
|
|
}
|
|
}
|
|
}
|