Struct ethcore::client::Client

pub struct Client { /* private fields */ }

Blockchain database client backed by a persistent database. Owns and manages a blockchain and a block queue. Call import_block() to import a block asynchronously; flush_queue() flushes the queue.

Implementations

impl Client

pub fn new(
    config: ClientConfig,
    spec: &Spec,
    db: Arc<dyn BlockChainDB>,
    miner: Arc<Miner>,
    message_channel: IoChannel<ClientIoMessage>
) -> Result<Arc<Client>, Error>

Create a new client with given parameters. The database is assumed to have been initialized with the correct columns.

pub fn shutdown(&self)

signals shutdown of application. We do cleanup here.

pub fn keep_alive(&self)

Wakes up client if it’s a sleep.

pub fn add_notify(&self, target: Arc<dyn ChainNotify>)

Adds an actor to be notified on certain events

pub fn engine(&self) -> &dyn EthEngine

Returns engine reference.

pub fn on_user_defaults_change<F>(&self, f: F) where
    F: 'static + FnMut(Option<Mode>) + Send, 

Register an action to be done if a mode/spec_name change happens.

pub fn flush_queue(&self)

Flush the block import queue.

pub fn latest_env_info(&self) -> EnvInfo

The env info as of the best block.

pub fn env_info(&self, id: BlockId) -> Option<EnvInfo>

The env info as of a given block. returns None if the block unknown.

pub fn import_verified_blocks(&self) -> usize

This is triggered by a message coming from a block queue when the block is ready for insertion

pub fn set_io_channel(&self, io_channel: IoChannel<ClientIoMessage>)

Replace io channel. Useful for testing.

pub fn latest_state_and_header(&self) -> (State<StateDB>, Header)

Get a copy of the best block’s state.

pub fn state_at(&self, id: BlockId) -> Option<State<StateDB>>

Attempt to get a copy of a specific block’s final state.

This will not fail if given BlockId::Latest. Otherwise, this can fail (but may not) if the DB prunes state or the block is unknown.

pub fn state_at_beginning(&self, id: BlockId) -> Option<State<StateDB>>

Attempt to get a copy of a specific block’s beginning state.

This will not fail if given BlockId::Latest. Otherwise, this can fail (but may not) if the DB prunes state.

pub fn state(&self) -> impl StateInfo

Get a copy of the best block’s state.

pub fn blockchain_cache_info(&self) -> BlockChainCacheSize

Get info on the cache.

pub fn report(&self) -> ClientReport

Get the report.

pub fn tick(&self, prevent_sleep: bool)

Tick the client.

pub fn take_snapshot<W: SnapshotWriter + Send>(
    &self,
    writer: W,
    at: BlockId,
    p: &Progress
) -> Result<(), EthcoreError>

Take a snapshot at the given block. If the ID given is “latest”, this will default to 1000 blocks behind.

pub fn pruning_history(&self) -> u64

Ask the client what the history parameter is.

Trait Implementations

impl BadBlocks for Client

fn bad_blocks(&self) -> Vec<(Unverified, String)>

Returns a list of blocks that were recently not imported because they were invalid.

impl Balance for Client

fn balance(&self, address: &Address, state: StateOrBlock) -> Option<U256>

Get address balance at the given block’s state.

fn latest_balance(&self, address: &Address) -> U256

Get address balance at the latest block’s state.

impl BlockChainClient for Client

fn replay(
    &self,
    id: TransactionId,
    analytics: CallAnalytics
) -> Result<Executed, CallError>

Replays a given transaction for inspection.

fn replay_block_transactions(
    &self,
    block: BlockId,
    analytics: CallAnalytics
) -> Result<Box<dyn Iterator<Item = (H256, Executed)>>, CallError>

Replays all the transactions in a given block for inspection.

fn mode(&self) -> Mode

Get the mode.

fn disable(&self)

Disable the client from importing blocks. This cannot be undone in this session and indicates that a subsystem has reason to believe this executable incapable of syncing the chain.

fn set_mode(&self, new_mode: Mode)

Set the mode.

fn spec_name(&self) -> String

Get the chain spec name.

fn is_canon(&self, hash: &H256) -> bool

Returns true if the given block is known and in the canon chain.

fn set_spec_name(&self, new_spec_name: String) -> Result<(), ()>

Set the chain via a spec name.

fn block_number(&self, id: BlockId) -> Option<BlockNumber>

Look up the block number for the given block ID.

fn block_body(&self, id: BlockId) -> Option<Body>

Get raw block body data by block id. Block body is an RLP list of two items: uncles and transactions.

fn block_status(&self, id: BlockId) -> BlockStatus

Get block status by block header hash.

fn is_processing_fork(&self) -> bool

Returns true, if underlying import queue is processing possible fork at the moment

fn block_total_difficulty(&self, id: BlockId) -> Option<U256>

Get block total difficulty.

fn storage_root(&self, address: &Address, id: BlockId) -> Option<H256>

Attempt to get address storage root at given block. May not fail on BlockId::Latest.

fn block_hash(&self, id: BlockId) -> Option<H256>

Get block hash.

fn code(&self, address: &Address, state: StateOrBlock) -> Option<Option<Bytes>>

Get address code at given block’s state.

fn storage_at(
    &self,
    address: &Address,
    position: &H256,
    state: StateOrBlock
) -> Option<H256>

Get address code hash at given block’s state. Get value of the storage at given position at the given block’s state.

fn list_accounts(
    &self,
    id: BlockId,
    after: Option<&Address>,
    count: u64
) -> Option<Vec<Address>>

Get a list of all accounts in the block id, if fat DB is in operation, otherwise None. If after is set the list starts with the following item.

fn list_storage(
    &self,
    id: BlockId,
    account: &Address,
    after: Option<&H256>,
    count: u64
) -> Option<Vec<H256>>

Get a list of all storage keys in the block id, if fat DB is in operation, otherwise None. If after is set the list starts with the following item.

fn block_transaction(&self, id: TransactionId) -> Option<LocalizedTransaction>

Get transaction with given hash.

fn queued_transaction(&self, hash: H256) -> Option<Arc<VerifiedTransaction>>

Get pool transaction with a given hash.

fn uncle(&self, id: UncleId) -> Option<Header>

Get uncle with given id.

fn transaction_receipt(&self, id: TransactionId) -> Option<LocalizedReceipt>

Get transaction receipt with given hash.

fn localized_block_receipts(&self, id: BlockId) -> Option<Vec<LocalizedReceipt>>

Get localized receipts for all transaction in given block.

fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute>

Get a tree route between from and to. See BlockChain::tree_route.

fn find_uncles(&self, hash: &H256) -> Option<Vec<H256>>

Get all possible uncle hashes for a block.

fn block_receipts(&self, hash: &H256) -> Option<BlockReceipts>

Get block receipts data by block header hash.

fn queue_info(&self) -> BlockQueueInfo

Get block queue information.

fn is_queue_empty(&self) -> bool

Returns true if block queue is empty.

fn clear_queue(&self)

Clear block queue and abort all import activity.

fn additional_params(&self) -> BTreeMap<String, String>

Get the registrar address, if it exists.

fn logs(&self, filter: Filter) -> Result<Vec<LocalizedLogEntry>, BlockId>

Returns logs matching given filter. If one of the filtering block cannot be found, returns the block id that caused the error.

fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>>

Returns traces matching given filter.

fn trace(&self, trace: TraceId) -> Option<LocalizedTrace>

Returns trace with given id.

fn transaction_traces(
    &self,
    transaction: TransactionId
) -> Option<Vec<LocalizedTrace>>

Returns traces created by transaction.

fn block_traces(&self, block: BlockId) -> Option<Vec<LocalizedTrace>>

Returns traces created by transaction from block.

fn last_hashes(&self) -> LastHashes

Get last hashes starting from best block.

fn transactions_to_propagate(&self) -> Vec<Arc<VerifiedTransaction>>

List all ready transactions that should be propagated to other peers.

fn transaction(&self, tx_hash: &H256) -> Option<Arc<VerifiedTransaction>>

Get verified transaction with specified transaction hash.

fn signing_chain_id(&self) -> Option<u64>

Get the preferred chain ID to sign on

fn block_extra_info(&self, id: BlockId) -> Option<BTreeMap<String, String>>

Returns engine-related extra info for BlockId.

fn uncle_extra_info(&self, id: UncleId) -> Option<BTreeMap<String, String>>

Returns engine-related extra info for UncleId.

fn pruning_info(&self) -> PruningInfo

Returns information about pruning/data availability.

fn create_transaction(
    &self,
    _: TransactionRequest
) -> Result<SignedTransaction, Error>

Returns a transaction signed with the key configured in the engine signer.

fn transact(&self, tx_request: TransactionRequest) -> Result<(), Error>

Schedule state-altering transaction to be executed on the next pending block with the given gas and nonce parameters.

fn registrar_address(&self) -> Option<Address>

Get the address of the registry itself.

fn state_data(&self, hash: &H256) -> Option<Bytes>

Get latest state node

fn latest_code(&self, address: &Address) -> Option<Bytes>

Get address code at the latest block’s state.

fn latest_storage_at(&self, address: &Address, position: &H256) -> H256

Get value of the storage at given position at the latest block’s state.

fn gas_price_corpus(&self, sample_size: usize) -> Corpus<U256>

Sorted list of transaction gas prices from at least last sample_size blocks.

fn priority_gas_price_corpus(
    &self,
    sample_size: usize,
    eip1559_transition: BlockNumber
) -> Corpus<U256>

Sorted list of transaction priority gas prices from at least last sample_size blocks.

impl BlockChainReset for Client

fn reset(&self, num: u32) -> Result<(), String>

reset to best_block - n

impl BlockInfo for Client

fn block_header(&self, id: BlockId) -> Option<Header>

Get raw block header data by block id.

fn best_block_header(&self) -> Header

Get the best block header.

fn block(&self, id: BlockId) -> Option<Block>

Get raw block data by block header hash.

fn code_hash(&self, address: &Address, id: BlockId) -> Option<H256>

Get address code hash at given block’s state.

impl BroadcastProposalBlock for Client

fn broadcast_proposal_block(&self, block: SealedBlock)

Broadcast a block proposal.

impl Call for Client

type State = State<StateDB>

Type representing chain state

fn call(
    &self,
    transaction: &SignedTransaction,
    analytics: CallAnalytics,
    state: &mut Self::State,
    header: &Header
) -> Result<Executed, CallError>

Makes a non-persistent transaction call.

fn call_many(
    &self,
    transactions: &[(SignedTransaction, CallAnalytics)],
    state: &mut Self::State,
    header: &Header
) -> Result<Vec<Executed>, CallError>

Makes multiple non-persistent but dependent transaction calls. Returns a vector of successes or a failure if any of the transaction fails.

fn estimate_gas(
    &self,
    t: &SignedTransaction,
    state: &Self::State,
    header: &Header
) -> Result<U256, CallError>

Estimates how much gas will be necessary for a call.

impl CallContract for Client

fn call_contract(
    &self,
    block_id: BlockId,
    address: Address,
    data: Bytes
) -> Result<Bytes, String>

Like call, but with various defaults. Designed to be used for calling contracts.

impl ChainInfo for Client

fn chain_info(&self) -> BlockChainInfo

Get blockchain information.

impl DatabaseRestore for Client

fn restore_db(&self, new_db: &str) -> Result<(), EthcoreError>

Restart the client with a new backend

impl Drop for Client

fn drop(&mut self)

Executes the destructor for this type.

impl EngineClient for Client

fn update_sealing(&self, force: ForceUpdateSealing)

Make a new block and seal it.

fn submit_seal(&self, block_hash: H256, seal: Vec<Bytes>)

Submit a seal for a block in the mining queue.

fn broadcast_consensus_message(&self, message: Bytes)

Broadcast a consensus message to the network.

fn epoch_transition_for(&self, parent_hash: H256) -> Option<EpochTransition>

Get the transition to the epoch the given parent hash is part of or transitions to. This will give the epoch that any children of this parent belong to.

fn as_full_client(&self) -> Option<&dyn BlockChainClient>

Attempt to cast the engine client to a full client.

fn block_number(&self, id: BlockId) -> Option<BlockNumber>

Get a block number by ID.

fn block_header(&self, id: BlockId) -> Option<Header>

Get raw block header data by block id.

impl EngineInfo for Client

fn engine(&self) -> &dyn EthEngine

Get underlying engine object

impl ImportBlock for Client

fn import_block(&self, unverified: Unverified) -> EthcoreResult<H256>

Import a block into the blockchain.

impl ImportExportBlocks for Client

fn export_blocks<'a>(
    &self,
    out: Box<dyn Write + 'a>,
    from: BlockId,
    to: BlockId,
    format: Option<DataFormat>
) -> Result<(), String>

Export blocks to destination, with the given from, to and format argument. destination could be a file or stdout. If the format is hex, each block is written on a new line. For binary exports, all block data is written to the same line.

fn import_blocks<'a>(
    &self,
    source: Box<dyn Read + 'a>,
    format: Option<DataFormat>
) -> Result<(), String>

Import blocks from destination, with the given format argument Source could be a file or stdout. For hex format imports, it attempts to read the blocks on a line by line basis. For binary format imports, reads the 8 byte RLP header in order to decode the block length to be read.

impl ImportSealedBlock for Client

fn import_sealed_block(&self, block: SealedBlock) -> EthcoreResult<H256>

Import sealed block. Skips all verifications.

impl IoClient for Client

fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize)

Queue transactions for importing.

fn queue_ancient_block(
    &self,
    unverified: Unverified,
    receipts_bytes: Bytes
) -> EthcoreResult<H256>

Queue block import with transaction receipts. Does no sealing and transaction validation.

fn ancient_block_queue_fullness(&self) -> f32

Return percentage of how full is queue that handles ancient blocks. 0 if empty, 1 if full.

fn queue_consensus_message(&self, message: Bytes)

Queue conensus engine message.

impl Nonce for Client

fn nonce(&self, address: &Address, id: BlockId) -> Option<U256>

Attempt to get address nonce at given block. May not fail on BlockId::Latest.

fn latest_nonce(&self, address: &Address) -> U256

Get address nonce at the latest block’s state.

impl PrepareOpenBlock for Client

fn prepare_open_block(
    &self,
    author: Address,
    gas_range_target: (U256, U256),
    extra_data: Bytes
) -> Result<OpenBlock<'_>, EthcoreError>

Returns OpenBlock prepared for closing.

impl PrometheusMetrics for Client

fn prometheus_metrics(&self, r: &mut PrometheusRegistry)

impl ProvingBlockChainClient for Client

fn prove_storage(
    &self,
    key1: H256,
    key2: H256,
    id: BlockId
) -> Option<(Vec<Bytes>, H256)>

Prove account storage at a specific block id.

fn prove_account(
    &self,
    key1: H256,
    id: BlockId
) -> Option<(Vec<Bytes>, BasicAccount)>

Prove account existence at a specific block id. The key is the keccak hash of the account’s address. Returns a vector of raw trie nodes (in order from the root) proving the query.

fn prove_transaction(
    &self,
    transaction: SignedTransaction,
    id: BlockId
) -> Option<(Bytes, Vec<DBValue>)>

Prove execution of a transaction at the given block. Returns the output of the call and a vector of database items necessary to reproduce it.

fn epoch_signal(&self, hash: H256) -> Option<Vec<u8>>

Get an epoch change signal by block hash.

impl RegistryInfo for Client

fn registry_address(&self, name: String, block: BlockId) -> Option<Address>

Get the address of a particular blockchain service, if available.

impl ReopenBlock for Client

fn reopen_block(&self, block: ClosedBlock) -> OpenBlock<'_>

Reopens an OpenBlock and updates uncles.

impl ScheduleInfo for Client

fn latest_schedule(&self) -> Schedule

Returns latest schedule.

impl StateClient for Client

type State = State<StateDB>

Type representing chain state

fn latest_state_and_header(&self) -> (Self::State, Header)

Get a copy of the best block’s state and header.

fn state_at(&self, id: BlockId) -> Option<Self::State>

Attempt to get a copy of a specific block’s final state.

impl TransactionInfo for Client

fn transaction_block(&self, id: TransactionId) -> Option<H256>

Get the hash of block that contains the transaction, if any.

impl AccountData for Client

impl BlockChain for Client

impl BlockChainClient for Client

impl BlockProducer for Client

impl SealedBlockImporter for Client

impl SnapshotClient for Client

impl TransactionVerifierClient for Client