Trait ethcore::miner::MinerService [−] [src]

pub trait MinerService: Send + Sync {
    type State: StateInfo + 'static;
    fn submit_seal(
        &self, 
        pow_hash: H256, 
        seal: Vec<Bytes>
    ) -> Result<SealedBlock, Error>;

    fn is_currently_sealing(&self) -> bool;

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

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

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

    fn pending_receipts(
        &self, 
        best_block: BlockNumber
    ) -> Option<BTreeMap<H256, Receipt>>;

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

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

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

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

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

    fn authoring_params(&self) -> AuthoringParams;

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

    fn set_extra_data(&self, extra_data: Bytes);

    fn set_author(
        &self, 
        address: Address, 
        password: Option<String>
    ) -> Result<(), SignError>;

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

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

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

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

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

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

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

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

    fn queue_status(&self) -> QueueStatus;

    fn sensible_gas_price(&self) -> U256;

    fn sensible_gas_limit(&self) -> U256;
}

Miner client API

Associated Types

Type representing chain state

Required Methods

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.

Is it currently sealing?

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

Returns None if engine seals internally.

Update current pending block

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.

Get a list of all pending receipts from pending block.

Get a particular receipt from pending block.

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

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

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

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

Get current authoring parameters.

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

Set the extra_data that we will seal blocks with.

Set info necessary to sign consensus messages and block authoring.

On PoW password is optional.

ⓘImportant traits for Vec<u8>

Imports transactions to transaction queue.

Imports own (node owner) transaction to queue.

Removes transaction from the pool.

Attempts to "cancel" a transaction. If it was not propagated yet (or not accepted by other peers) there is a good chance that the transaction will actually be removed. NOTE: The transaction is not removed from pending block if there is one.

Query transaction from the pool given it's hash.

Returns next valid nonce for given address.

This includes nonces of all transactions from this address in the pending queue if they are consecutive. NOTE: pool may contain some future transactions that will become pending after transaction with nonce returned from this function is signed on.

ⓘImportant traits for Vec<u8>

Get a list of all ready transactions either ordered by priority or unordered (cheaper).

Depending on the settings may look in transaction pool or only in pending block. If you don't need a full set of transactions, you can add max_len and create only a limited set of transactions.

ⓘImportant traits for Vec<u8>

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

Get a list of local transactions with statuses.

Get current queue status.

Status includes verification thresholds and current pool utilization and limits.

Suggested gas price.

Suggested gas limit.

Implementors