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
181 lines
6.5 KiB
Rust
181 lines
6.5 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/>.
|
|
|
|
//! Traces api implementation.
|
|
|
|
use std::sync::Arc;
|
|
|
|
use ethcore::client::{MiningBlockChainClient, CallAnalytics, TransactionId, TraceId, StateClient, StateInfo, Call, BlockId};
|
|
use rlp::UntrustedRlp;
|
|
use transaction::SignedTransaction;
|
|
|
|
use jsonrpc_core::Result;
|
|
use jsonrpc_macros::Trailing;
|
|
use v1::Metadata;
|
|
use v1::traits::Traces;
|
|
use v1::helpers::{errors, fake_sign};
|
|
use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults, TraceOptions, H256, block_number_to_id};
|
|
|
|
fn to_call_analytics(flags: TraceOptions) -> CallAnalytics {
|
|
CallAnalytics {
|
|
transaction_tracing: flags.contains(&("trace".to_owned())),
|
|
vm_tracing: flags.contains(&("vmTrace".to_owned())),
|
|
state_diffing: flags.contains(&("stateDiff".to_owned())),
|
|
}
|
|
}
|
|
|
|
/// Traces api implementation.
|
|
pub struct TracesClient<C> {
|
|
client: Arc<C>,
|
|
}
|
|
|
|
impl<C> TracesClient<C> {
|
|
/// Creates new Traces client.
|
|
pub fn new(client: &Arc<C>) -> Self {
|
|
TracesClient {
|
|
client: client.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<C, S> Traces for TracesClient<C> where
|
|
S: StateInfo + 'static,
|
|
C: MiningBlockChainClient + StateClient<State=S> + Call<State=S> + 'static
|
|
{
|
|
type Metadata = Metadata;
|
|
|
|
fn filter(&self, filter: TraceFilter) -> Result<Option<Vec<LocalizedTrace>>> {
|
|
Ok(self.client.filter_traces(filter.into())
|
|
.map(|traces| traces.into_iter().map(LocalizedTrace::from).collect()))
|
|
}
|
|
|
|
fn block_traces(&self, block_number: BlockNumber) -> Result<Option<Vec<LocalizedTrace>>> {
|
|
let id = match block_number {
|
|
BlockNumber::Pending => return Ok(None),
|
|
num => block_number_to_id(num)
|
|
};
|
|
|
|
Ok(self.client.block_traces(id)
|
|
.map(|traces| traces.into_iter().map(LocalizedTrace::from).collect()))
|
|
}
|
|
|
|
fn transaction_traces(&self, transaction_hash: H256) -> Result<Option<Vec<LocalizedTrace>>> {
|
|
Ok(self.client.transaction_traces(TransactionId::Hash(transaction_hash.into()))
|
|
.map(|traces| traces.into_iter().map(LocalizedTrace::from).collect()))
|
|
}
|
|
|
|
fn trace(&self, transaction_hash: H256, address: Vec<Index>) -> Result<Option<LocalizedTrace>> {
|
|
let id = TraceId {
|
|
transaction: TransactionId::Hash(transaction_hash.into()),
|
|
address: address.into_iter().map(|i| i.value()).collect()
|
|
};
|
|
|
|
Ok(self.client.trace(id)
|
|
.map(LocalizedTrace::from))
|
|
}
|
|
|
|
fn call(&self, meta: Self::Metadata, request: CallRequest, flags: TraceOptions, block: Trailing<BlockNumber>) -> Result<TraceResults> {
|
|
let block = block.unwrap_or_default();
|
|
|
|
let request = CallRequest::into(request);
|
|
let signed = fake_sign::sign_call(request, meta.is_dapp())?;
|
|
|
|
let id = match block {
|
|
BlockNumber::Num(num) => BlockId::Number(num),
|
|
BlockNumber::Earliest => BlockId::Earliest,
|
|
BlockNumber::Latest => BlockId::Latest,
|
|
|
|
BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())),
|
|
};
|
|
|
|
let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?;
|
|
let header = self.client.block_header(id).ok_or(errors::state_pruned())?;
|
|
|
|
self.client.call(&signed, to_call_analytics(flags), &mut state, &header.decode())
|
|
.map(TraceResults::from)
|
|
.map_err(errors::call)
|
|
}
|
|
|
|
fn call_many(&self, meta: Self::Metadata, requests: Vec<(CallRequest, TraceOptions)>, block: Trailing<BlockNumber>) -> Result<Vec<TraceResults>> {
|
|
let block = block.unwrap_or_default();
|
|
|
|
let requests = requests.into_iter()
|
|
.map(|(request, flags)| {
|
|
let request = CallRequest::into(request);
|
|
let signed = fake_sign::sign_call(request, meta.is_dapp())?;
|
|
Ok((signed, to_call_analytics(flags)))
|
|
})
|
|
.collect::<Result<Vec<_>>>()?;
|
|
|
|
let id = match block {
|
|
BlockNumber::Num(num) => BlockId::Number(num),
|
|
BlockNumber::Earliest => BlockId::Earliest,
|
|
BlockNumber::Latest => BlockId::Latest,
|
|
|
|
BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())),
|
|
};
|
|
|
|
let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?;
|
|
let header = self.client.block_header(id).ok_or(errors::state_pruned())?;
|
|
|
|
self.client.call_many(&requests, &mut state, &header.decode())
|
|
.map(|results| results.into_iter().map(TraceResults::from).collect())
|
|
.map_err(errors::call)
|
|
}
|
|
|
|
fn raw_transaction(&self, raw_transaction: Bytes, flags: TraceOptions, block: Trailing<BlockNumber>) -> Result<TraceResults> {
|
|
let block = block.unwrap_or_default();
|
|
|
|
let tx = UntrustedRlp::new(&raw_transaction.into_vec()).as_val().map_err(|e| errors::invalid_params("Transaction is not valid RLP", e))?;
|
|
let signed = SignedTransaction::new(tx).map_err(errors::transaction)?;
|
|
|
|
let id = match block {
|
|
BlockNumber::Num(num) => BlockId::Number(num),
|
|
BlockNumber::Earliest => BlockId::Earliest,
|
|
BlockNumber::Latest => BlockId::Latest,
|
|
|
|
BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())),
|
|
};
|
|
|
|
let mut state = self.client.state_at(id).ok_or(errors::state_pruned())?;
|
|
let header = self.client.block_header(id).ok_or(errors::state_pruned())?;
|
|
|
|
self.client.call(&signed, to_call_analytics(flags), &mut state, &header.decode())
|
|
.map(TraceResults::from)
|
|
.map_err(errors::call)
|
|
}
|
|
|
|
fn replay_transaction(&self, transaction_hash: H256, flags: TraceOptions) -> Result<TraceResults> {
|
|
self.client.replay(TransactionId::Hash(transaction_hash.into()), to_call_analytics(flags))
|
|
.map(TraceResults::from)
|
|
.map_err(errors::call)
|
|
}
|
|
|
|
fn replay_block_transactions(&self, block_number: BlockNumber, flags: TraceOptions) -> Result<Vec<TraceResults>> {
|
|
let id = match block_number {
|
|
BlockNumber::Num(num) => BlockId::Number(num),
|
|
BlockNumber::Earliest => BlockId::Earliest,
|
|
BlockNumber::Latest => BlockId::Latest,
|
|
|
|
BlockNumber::Pending => return Err(errors::invalid_params("`BlockNumber::Pending` is not supported", ())),
|
|
};
|
|
|
|
self.client.replay_block_transactions(id, to_call_analytics(flags))
|
|
.map(|results| results.into_iter().map(TraceResults::from).collect())
|
|
.map_err(errors::call)
|
|
}
|
|
}
|