9d7d6f7108
* Improves `BestBlock` comment * Improves `TraceDB` comment * Improves `journaldb::Algorithm` comment. Probably the whole enum should be renamed to `Strategy` or something alike. * Comments some of the `Client`'s fields * Deglobs client imports * Fixes comments * Extracts `import_lock` to `Importer` struct * Extracts `verifier` to `Importer` struct * Extracts `block_queue` to `Importer` struct * Extracts `miner` to `Importer` struct * Extracts `ancient_verifier` to `Importer` struct * Extracts `rng` to `Importer` struct * Extracts `import_old_block` to `Importer` struct * Adds `Nonce` trait * Adds `Balance` trait * Adds `ChainInfo` trait * Fixes imports for tests using `chain_info` method * Adds `BlockInfo` trait * Adds more `ChainInfo` imports * Adds `BlockInfo` imports * Adds `ReopenBlock` trait * Adds `PrepareOpenBlock` trait * Fixes import in tests * Adds `CallContract` trait * Fixes imports in tests using `call_contract` method * Adds `TransactionInfo` trait * Adds `RegistryInfo` trait * Fixes imports in tests using `registry_address` method * Adds `ScheduleInfo` trait * Adds `ImportSealedBlock` trait * Fixes imports in test using `import_sealed_block` method * Adds `BroadcastProposalBlock` trait * Migrates `Miner` to static dispatch * Fixes tests * Moves `calculate_enacted_retracted` to `Importer` * Moves import-related methods to `Importer` * Removes redundant `import_old_block` wrapper * Extracts `import_block*` into separate trait * Fixes tests * Handles `Pending` in `LightFetch` * Handles `Pending` in filters * Handles `Pending` in `ParityClient` * Handles `Pending` in `EthClient` * Removes `BlockId::Pending`, partly refactors dependent code * Adds `StateInfo` trait * Exports `StateOrBlock` and `BlockChain` types from `client` module * Refactors `balance` RPC using generic API * Refactors `storage_at` RPC using generic API * Makes `MinerService::pending_state`'s return type dynamic * Adds `StateOrBlock` and `BlockChain` types * Adds impl of `client::BlockChain` for `Client` * Exports `StateInfo` trait from `client` module * Missing `self` use To be fixed up to "Adds impl of `client::BlockChain` for `Client`" * Adds `number_to_id` and refactors dependent RPC methods * Refactors `code_at` using generic API * Adds `StateClient` trait * Refactors RPC to use `StateClient` trait * Reverts `client::BlockChain` trait stuff, refactors methods to accept `StateOrBlock` * Refactors TestClient * Adds helper function `block_number_to_id` * Uses `block_number_to_id` instead of local function * Handles `Pending` in `list_accounts` and `list_storage_keys` * Attempt to use associated types for state instead of trait objects * Simplifies `state_at_beginning` * Extracts `call` and `call_many` into separate trait * Refactors `build_last_hashes` to accept reference * Exports `Call` type from the module * Refactors `call` and `call_many` to accept state and header * Exports `state_at` in `StateClient` * Exports `pending_block_header` from `MinerService` * Refactors RPC `call` method using new API * Adds missing parentheses * Refactors `parity::call` to use new call API * Update .gitlab-ci.yml fix gitlab lint * Fixes error handling * Refactors `traces::call` and `call_many` to use new call API * Refactors `call_contract` * Refactors `block_header` * Refactors internal RPC method `block` * Moves `estimate_gas` to `Call` trait, refactors parameters * Refactors `estimate_gas` in RPC * Refactors `uncle` * Refactors RPC `transaction` * Covers missing branches * Makes it all compile, fixes compiler grumbles * Adds casts in `blockchain` module * Fixes `PendingBlock` tests, work on `MinerService` * Adds test stubs for StateClient and EngineInfo * Makes `state_db` public * Adds missing impls for `TestBlockChainClient` * Adds trait documentation * Adds missing docs to the `state_db` module * Fixes trivial compilation errors * Moves `code_hash` method to a `BlockInfo` trait * Refactors `Verifier` to be generic over client * Refactors `TransactionFilter` to be generic over client * Refactors `Miner` and `Client` to reflect changes in verifier and txfilter API * Moves `ServiceTransactionChecker` back to `ethcore` * Fixes trait bounds in `Miner` API * Fixes `Client` * Fixes lifetime bound in `FullFamilyParams` * Adds comments to `FullFamilyParams` * Fixes imports in `ethcore` * Fixes BlockNumber handling in `code_at` and `replay_block_transactions` * fix compile issues * First step to redundant trait merge * Fixes compilation error in RPC tests * Adds mock `State` as a stub for `TestClient` * Handles `StateOrBlock::State` in `TestBlockChainClient::balance` * Fixes `transaction_count` RPC * Fixes `transaction_count` * Moves `service_transaction.json` to the `contracts` subfolder * Fixes compilation errors in tests * Refactors client to use `AccountData` * Refactors client to use `BlockChain` * Refactors miner to use aggregate traits * Adds `SealedBlockImporter` trait * Refactors miner to use `SealedBlockImporter` trait * Removes unused imports * Simplifies `RegistryInfo::registry_address` * Fixes indentation * Removes commented out trait bound
313 lines
8.3 KiB
Rust
313 lines
8.3 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/>.
|
|
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
|
|
use bytes::Bytes;
|
|
use dir::default_data_path;
|
|
use dir::helpers::replace_home;
|
|
use ethcore::client::{Client, BlockChainClient, BlockId, CallContract};
|
|
use ethsync::LightSync;
|
|
use futures::{Future, future, IntoFuture};
|
|
use hash_fetch::fetch::Client as FetchClient;
|
|
use hash_fetch::urlhint::ContractClient;
|
|
use light::client::LightChainClient;
|
|
use light::on_demand::{self, OnDemand};
|
|
use node_health::{SyncStatus, NodeHealth};
|
|
use rpc;
|
|
use rpc_apis::SignerService;
|
|
use transaction::{Transaction, Action};
|
|
use ethereum_types::Address;
|
|
|
|
#[derive(Debug, PartialEq, Clone)]
|
|
pub struct Configuration {
|
|
pub enabled: bool,
|
|
pub dapps_path: PathBuf,
|
|
pub extra_dapps: Vec<PathBuf>,
|
|
pub extra_embed_on: Vec<(String, u16)>,
|
|
pub extra_script_src: Vec<(String, u16)>,
|
|
}
|
|
|
|
impl Default for Configuration {
|
|
fn default() -> Self {
|
|
let data_dir = default_data_path();
|
|
Configuration {
|
|
enabled: true,
|
|
dapps_path: replace_home(&data_dir, "$BASE/dapps").into(),
|
|
extra_dapps: vec![],
|
|
extra_embed_on: vec![],
|
|
extra_script_src: vec![],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Configuration {
|
|
pub fn address(&self, address: Option<::parity_rpc::Host>) -> Option<::parity_rpc::Host> {
|
|
match self.enabled {
|
|
true => address,
|
|
false => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Registrar implementation of the full client.
|
|
pub struct FullRegistrar {
|
|
/// Handle to the full client.
|
|
pub client: Arc<Client>,
|
|
}
|
|
|
|
impl FullRegistrar {
|
|
pub fn new(client: Arc<Client>) -> Self {
|
|
FullRegistrar {
|
|
client,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ContractClient for FullRegistrar {
|
|
fn registrar(&self) -> Result<Address, String> {
|
|
self.client.registrar_address()
|
|
.ok_or_else(|| "Registrar not defined.".into())
|
|
}
|
|
|
|
fn call(&self, address: Address, data: Bytes) -> Box<Future<Item = Bytes, Error = String> + Send> {
|
|
Box::new(self.client.call_contract(BlockId::Latest, address, data).into_future())
|
|
}
|
|
}
|
|
|
|
/// Registrar implementation for the light client.
|
|
pub struct LightRegistrar<T> {
|
|
/// The light client.
|
|
pub client: Arc<T>,
|
|
/// Handle to the on-demand service.
|
|
pub on_demand: Arc<OnDemand>,
|
|
/// Handle to the light network service.
|
|
pub sync: Arc<LightSync>,
|
|
}
|
|
|
|
impl<T: LightChainClient + 'static> ContractClient for LightRegistrar<T> {
|
|
fn registrar(&self) -> Result<Address, String> {
|
|
self.client.engine().additional_params().get("registrar")
|
|
.ok_or_else(|| "Registrar not defined.".into())
|
|
.and_then(|registrar| {
|
|
registrar.parse().map_err(|e| format!("Invalid registrar address: {:?}", e))
|
|
})
|
|
}
|
|
|
|
fn call(&self, address: Address, data: Bytes) -> Box<Future<Item = Bytes, Error = String> + Send> {
|
|
let header = self.client.best_block_header();
|
|
let env_info = self.client.env_info(BlockId::Hash(header.hash()))
|
|
.ok_or_else(|| format!("Cannot fetch env info for header {}", header.hash()));
|
|
|
|
let env_info = match env_info {
|
|
Ok(e) => e,
|
|
Err(e) => return Box::new(future::err(e)),
|
|
};
|
|
|
|
let maybe_future = self.sync.with_context(move |ctx| {
|
|
self.on_demand
|
|
.request(ctx, on_demand::request::TransactionProof {
|
|
tx: Transaction {
|
|
nonce: self.client.engine().account_start_nonce(header.number()),
|
|
action: Action::Call(address),
|
|
gas: 50_000.into(), // should be enough for all registry lookups. TODO: exponential backoff
|
|
gas_price: 0.into(),
|
|
value: 0.into(),
|
|
data: data,
|
|
}.fake_sign(Address::default()),
|
|
header: header.into(),
|
|
env_info: env_info,
|
|
engine: self.client.engine().clone(),
|
|
})
|
|
.expect("No back-references; therefore all back-refs valid; qed")
|
|
.then(|res| match res {
|
|
Ok(Ok(executed)) => Ok(executed.output),
|
|
Ok(Err(e)) => Err(format!("Failed to execute transaction: {}", e)),
|
|
Err(_) => Err(format!("On-demand service dropped request unexpectedly.")),
|
|
})
|
|
});
|
|
|
|
match maybe_future {
|
|
Some(fut) => Box::new(fut),
|
|
None => Box::new(future::err("cannot query registry: network disabled".into())),
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: light client implementation forwarding to OnDemand and waiting for future
|
|
// to resolve.
|
|
#[derive(Clone)]
|
|
pub struct Dependencies {
|
|
pub node_health: NodeHealth,
|
|
pub sync_status: Arc<SyncStatus>,
|
|
pub contract_client: Arc<ContractClient>,
|
|
pub fetch: FetchClient,
|
|
pub signer: Arc<SignerService>,
|
|
pub ui_address: Option<(String, u16)>,
|
|
}
|
|
|
|
pub fn new(configuration: Configuration, deps: Dependencies) -> Result<Option<Middleware>, String> {
|
|
if !configuration.enabled {
|
|
return Ok(None);
|
|
}
|
|
|
|
server::dapps_middleware(
|
|
deps,
|
|
configuration.dapps_path,
|
|
configuration.extra_dapps,
|
|
rpc::DAPPS_DOMAIN,
|
|
configuration.extra_embed_on,
|
|
configuration.extra_script_src,
|
|
).map(Some)
|
|
}
|
|
|
|
pub fn new_ui(enabled: bool, deps: Dependencies) -> Result<Option<Middleware>, String> {
|
|
if !enabled {
|
|
return Ok(None);
|
|
}
|
|
|
|
server::ui_middleware(
|
|
deps,
|
|
rpc::DAPPS_DOMAIN,
|
|
).map(Some)
|
|
}
|
|
|
|
pub use self::server::{Middleware, service};
|
|
|
|
#[cfg(not(feature = "dapps"))]
|
|
mod server {
|
|
use super::Dependencies;
|
|
use std::sync::Arc;
|
|
use std::path::PathBuf;
|
|
use parity_rpc::{hyper, RequestMiddleware, RequestMiddlewareAction};
|
|
use rpc_apis;
|
|
|
|
pub struct Middleware;
|
|
impl RequestMiddleware for Middleware {
|
|
fn on_request(&self, _req: hyper::Request) -> RequestMiddlewareAction {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
pub fn dapps_middleware(
|
|
_deps: Dependencies,
|
|
_dapps_path: PathBuf,
|
|
_extra_dapps: Vec<PathBuf>,
|
|
_dapps_domain: &str,
|
|
_extra_embed_on: Vec<(String, u16)>,
|
|
_extra_script_src: Vec<(String, u16)>,
|
|
) -> Result<Middleware, String> {
|
|
Err("Your Parity version has been compiled without WebApps support.".into())
|
|
}
|
|
|
|
pub fn ui_middleware(
|
|
_deps: Dependencies,
|
|
_dapps_domain: &str,
|
|
) -> Result<Middleware, String> {
|
|
Err("Your Parity version has been compiled without UI support.".into())
|
|
}
|
|
|
|
pub fn service(_: &Option<Middleware>) -> Option<Arc<rpc_apis::DappsService>> {
|
|
None
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "dapps")]
|
|
mod server {
|
|
use super::Dependencies;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
use rpc_apis;
|
|
|
|
use parity_dapps;
|
|
|
|
pub use parity_dapps::Middleware;
|
|
|
|
pub fn dapps_middleware(
|
|
deps: Dependencies,
|
|
dapps_path: PathBuf,
|
|
extra_dapps: Vec<PathBuf>,
|
|
dapps_domain: &str,
|
|
extra_embed_on: Vec<(String, u16)>,
|
|
extra_script_src: Vec<(String, u16)>,
|
|
) -> Result<Middleware, String> {
|
|
let signer = deps.signer;
|
|
let web_proxy_tokens = Arc::new(move |token| signer.web_proxy_access_token_domain(&token));
|
|
|
|
Ok(parity_dapps::Middleware::dapps(
|
|
deps.fetch.pool(),
|
|
deps.node_health,
|
|
deps.ui_address,
|
|
extra_embed_on,
|
|
extra_script_src,
|
|
dapps_path,
|
|
extra_dapps,
|
|
dapps_domain,
|
|
deps.contract_client,
|
|
deps.sync_status,
|
|
web_proxy_tokens,
|
|
deps.fetch,
|
|
))
|
|
}
|
|
|
|
pub fn ui_middleware(
|
|
deps: Dependencies,
|
|
dapps_domain: &str,
|
|
) -> Result<Middleware, String> {
|
|
Ok(parity_dapps::Middleware::ui(
|
|
deps.fetch.pool(),
|
|
deps.node_health,
|
|
dapps_domain,
|
|
deps.contract_client,
|
|
deps.sync_status,
|
|
deps.fetch,
|
|
))
|
|
}
|
|
|
|
pub fn service(middleware: &Option<Middleware>) -> Option<Arc<rpc_apis::DappsService>> {
|
|
middleware.as_ref().map(|m| Arc::new(DappsServiceWrapper {
|
|
endpoints: m.endpoints().clone(),
|
|
}) as Arc<rpc_apis::DappsService>)
|
|
}
|
|
|
|
pub struct DappsServiceWrapper {
|
|
endpoints: parity_dapps::Endpoints,
|
|
}
|
|
|
|
impl rpc_apis::DappsService for DappsServiceWrapper {
|
|
fn list_dapps(&self) -> Vec<rpc_apis::LocalDapp> {
|
|
self.endpoints.list()
|
|
.into_iter()
|
|
.map(|app| rpc_apis::LocalDapp {
|
|
id: app.id.unwrap_or_else(|| "unknown".into()),
|
|
name: app.name,
|
|
description: app.description,
|
|
version: app.version,
|
|
author: app.author,
|
|
icon_url: app.icon_url,
|
|
local_url: app.local_url,
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn refresh_local_dapps(&self) -> bool {
|
|
self.endpoints.refresh_local_dapps();
|
|
true
|
|
}
|
|
}
|
|
}
|