Struct ethcore::miner::Miner

pub struct Miner { /* private fields */ }

Keeps track of transactions using priority queue and holds currently mined block. Handles preparing work for “work sealing” or seals “internally” if Engine does not require work.

Implementations

impl Miner

pub fn add_work_listener(&self, notifier: Box<dyn NotifyWork>)

Push listener that will handle new jobs

pub fn add_transactions_listener(&self, f: Box<dyn Fn(&[H256]) + Send + Sync>)

Set a callback to be notified about imported transactions’ hashes.

pub fn new<A: LocalAccounts + 'static>(
    options: MinerOptions,
    gas_pricer: GasPricer,
    spec: &Spec,
    accounts: A
) -> Self

Creates new instance of miner Arc.

pub fn new_for_tests(spec: &Spec, accounts: Option<HashSet<Address>>) -> Miner

Creates new instance of miner with given spec and accounts.

NOTE This should be only used for tests.

pub fn new_for_tests_force_sealing(
    spec: &Spec,
    accounts: Option<HashSet<Address>>,
    force_sealing: bool
) -> Miner

Creates new instance of miner with given spec and accounts.

NOTE This should be only used for tests.

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

Sets IoChannel

pub fn set_in_chain_checker<C>(&self, chain: &Arc<C>) where
    C: TransactionInfo + Send + Sync + 'static, 

Sets in-blockchain checker for transactions.

pub fn clear(&self)

Clear all pending block states

pub fn update_transaction_queue_limits(
    &self,
    block_gas_limit: U256,
    block_base_fee: Option<U256>,
    allow_non_eoa_sender: bool
)

Updates transaction queue verification limits.

Limits consist of current block gas limit and minimal gas price.

pub fn service_transaction_checker(&self) -> Option<ServiceTransactionChecker>

Returns ServiceTransactionChecker

Trait Implementations

impl MinerService for Miner

fn update_sealing<C>(&self, chain: &C, force: ForceUpdateSealing) where
    C: BlockChain + CallContract + BlockProducer + SealedBlockImporter + Nonce + Sync, 

Prepare the block and work if the Engine does not seal internally.

type State = State<StateDB>

Type representing chain state

fn authoring_params(&self) -> AuthoringParams

Get current authoring parameters.

fn set_gas_range_target(&self, gas_range_target: (U256, U256))

Set the lower and upper bound of gas limit we wish to target when sealing a new block.

fn set_extra_data(&self, extra_data: Bytes)

Set the extra_data that we will seal blocks with.

fn set_author<T: Into<Option<Author>>>(&self, author: T)

Set info necessary to sign consensus messages and block authoring.

fn sensible_gas_price(&self) -> U256

Suggested gas price.

fn sensible_max_priority_fee(&self) -> U256

Suggested max priority fee gas price

fn sensible_gas_limit(&self) -> U256

Suggested gas limit.

fn set_minimal_gas_price(&self, new_price: U256) -> Result<bool, &str>

Set a new minimum gas limit. Will not work if dynamic gas calibration is set.

fn import_external_transactions<C: BlockChainClient>(
    &self,
    chain: &C,
    transactions: Vec<UnverifiedTransaction>
) -> Vec<Result<(), Error>>

Imports transactions to transaction queue.

fn import_own_transaction<C: BlockChainClient>(
    &self,
    chain: &C,
    pending: PendingTransaction
) -> Result<(), Error>

Imports own (node owner) transaction to queue.

fn import_claimed_local_transaction<C: BlockChainClient>(
    &self,
    chain: &C,
    pending: PendingTransaction,
    trusted: bool
) -> Result<(), Error>

Imports transactions from potentially external sources, with behaviour determined by the config flag tx_queue_allow_unfamiliar_locals

fn local_transactions(&self) -> BTreeMap<H256, Status>

Get a list of local transactions with statuses.

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

Get a list of all transactions in the pool (some of them might not be ready for inclusion yet).

fn queued_transaction_hashes(&self) -> Vec<H256>

Get a list of all transaction hashes in the pool (some of them might not be ready for inclusion yet).

fn pending_transaction_hashes<C>(&self, chain: &C) -> BTreeSet<H256> where
    C: ChainInfo + Sync, 

Get a set of all pending transaction hashes.

fn ready_transactions_filtered<C>(
    &self,
    chain: &C,
    max_len: usize,
    filter: Option<TransactionFilter>,
    ordering: PendingOrdering
) -> Vec<Arc<VerifiedTransaction>> where
    C: BlockChain + Nonce + Sync, 

Get a list of all ready transactions either ordered by priority or unordered (cheaper), and optionally filtered by sender, recipient, gas, gas price, value and/or nonce.

fn next_nonce<C>(&self, chain: &C, address: &Address) -> U256 where
    C: Nonce + Sync, 

Returns next valid nonce for given address.

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

Query transaction from the pool given it’s hash.

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

Removes transaction from the pool.

fn queue_status(&self) -> QueueStatus

Get current queue status.

fn pending_receipts(&self, best_block: BlockNumber) -> Option<Vec<RichReceipt>>

Get a list of all pending receipts from pending block.

fn is_currently_sealing(&self) -> bool

Is it currently sealing?

fn work_package<C>(&self, chain: &C) -> Option<(H256, BlockNumber, u64, U256)> where
    C: BlockChain + CallContract + BlockProducer + SealedBlockImporter + Nonce + Sync, 

Get the sealing work package preparing it if doesn’t exist yet.

fn submit_seal(
    &self,
    block_hash: H256,
    seal: Vec<Bytes>
) -> Result<SealedBlock, Error>

Submit seal as a valid solution for the header of pow_hash. Will check the seal, but not actually insert the block into the chain.

fn chain_new_blocks<C>(
    &self,
    chain: &C,
    imported: &[H256],
    _invalid: &[H256],
    enacted: &[H256],
    retracted: &[H256],
    is_internal_import: bool
) where
    C: BlockChainClient, 

Called when blocks are imported to chain, updates transactions queue. is_internal_import indicates that the block has just been created in miner and internally sealed by the engine, so we shouldn’t attempt creating new block again.

fn pending_state(&self, latest_block_number: BlockNumber) -> Option<Self::State>

Get Some clone() of the current pending block’s state or None if we’re not sealing.

fn pending_block_header(
    &self,
    latest_block_number: BlockNumber
) -> Option<Header>

Get Some clone() of the current pending block header or None if we’re not sealing.

fn pending_block(&self, latest_block_number: BlockNumber) -> Option<Block>

Get Some clone() of the current pending block or None if we’re not sealing.

fn pending_transactions(
    &self,
    latest_block_number: BlockNumber
) -> Option<Vec<SignedTransaction>>

Get Some clone() of the current pending block transactions or None if we’re not sealing.

fn pending_receipt(
    &self,
    best_block: BlockNumber,
    hash: &H256
) -> Option<RichReceipt>

Get a particular receipt from pending block.

fn ready_transactions<C>(
    &self,
    chain: &C,
    max_len: usize,
    ordering: PendingOrdering
) -> Vec<Arc<VerifiedTransaction>> where
    C: BlockChain + Nonce + Sync, 

Get an unfiltered list of all ready transactions.