openethereum/rpc/src/v1/impls/parity.rs

// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum 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.

// OpenEthereum 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 OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

//! Parity-specific rpc implementation.
use std::{collections::BTreeMap, str::FromStr, sync::Arc};

use crypto::DEFAULT_MAC;
use ethcore::{
    client::{BlockChainClient, Call, StateClient},
    miner::{self, MinerService},
    snapshot::{RestorationStatus, SnapshotService},
    state::StateInfo,
};
use ethcore_logger::RotatingLogger;
use ethereum_types::{Address, H160, H256, H512, H64, U256, U64};
use ethkey::{crypto::ecies, Brain, Generator};
use ethstore::random_phrase;
use jsonrpc_core::{futures::future, BoxFuture, Result};
use stats::PrometheusMetrics;
use sync::{ManageNetwork, SyncProvider};
use types::ids::BlockId;
use version::version_data;

use v1::{
    helpers::{
        self,
        block_import::is_major_importing,
        errors,
        external_signer::{SignerService, SigningQueue},
        fake_sign, verify_signature, NetworkSettings,
    },
    metadata::Metadata,
    traits::Parity,
    types::{
        block_number_to_id, BlockNumber, Bytes, CallRequest, ChainStatus, Histogram,
        LocalTransactionStatus, Peers, Receipt, RecoveredAccount, RichHeader, RpcSettings,
        Transaction, TransactionStats,
    },
};
use Host;

/// Parity implementation.
pub struct ParityClient<C, M>
where
    C: PrometheusMetrics,
{
    client: Arc<C>,
    miner: Arc<M>,
    sync: Arc<dyn SyncProvider>,
    net: Arc<dyn ManageNetwork>,
    logger: Arc<RotatingLogger>,
    settings: Arc<NetworkSettings>,
    signer: Option<Arc<SignerService>>,
    ws_address: Option<Host>,
    snapshot: Option<Arc<dyn SnapshotService>>,
}

impl<C, M> ParityClient<C, M>
where
    C: BlockChainClient + PrometheusMetrics,
{
    /// Creates new `ParityClient`.
    pub fn new(
        client: Arc<C>,
        miner: Arc<M>,
        sync: Arc<dyn SyncProvider>,
        net: Arc<dyn ManageNetwork>,
        logger: Arc<RotatingLogger>,
        settings: Arc<NetworkSettings>,
        signer: Option<Arc<SignerService>>,
        ws_address: Option<Host>,
        snapshot: Option<Arc<dyn SnapshotService>>,
    ) -> Self {
        ParityClient {
            client,
            miner,
            sync,
            net,
            logger,
            settings,
            signer,
            ws_address,
            snapshot,
        }
    }
}

impl<C, M, S> Parity for ParityClient<C, M>
where
    S: StateInfo + 'static,
    C: miner::BlockChainClient
        + BlockChainClient
        + PrometheusMetrics
        + StateClient<State = S>
        + Call<State = S>
        + 'static,
    M: MinerService<State = S> + 'static,
{
    type Metadata = Metadata;

    fn transactions_limit(&self) -> Result<usize> {
        Ok(self.miner.queue_status().limits.max_count)
    }

    fn min_gas_price(&self) -> Result<U256> {
        Ok(self.miner.queue_status().options.minimal_gas_price)
    }

    fn extra_data(&self) -> Result<Bytes> {
        Ok(Bytes::new(self.miner.authoring_params().extra_data))
    }

    fn gas_floor_target(&self) -> Result<U256> {
        Ok(self.miner.authoring_params().gas_range_target.0)
    }

    fn gas_ceil_target(&self) -> Result<U256> {
        Ok(self.miner.authoring_params().gas_range_target.1)
    }

    fn dev_logs(&self) -> Result<Vec<String>> {
        warn!("This method is deprecated and will be removed in future. See PR #10102");
        let logs = self.logger.logs();
        Ok(logs.as_slice().to_owned())
    }

    fn dev_logs_levels(&self) -> Result<String> {
        Ok(self.logger.levels().to_owned())
    }

    fn net_chain(&self) -> Result<String> {
        Ok(self.settings.chain.clone())
    }

    fn chain(&self) -> Result<String> {
        Ok(self.client.spec_name())
    }

    fn net_peers(&self) -> Result<Peers> {
        let sync_status = self.sync.status();
        let num_peers_range = self.net.num_peers_range();
        debug_assert!(num_peers_range.end() >= num_peers_range.start());
        let peers = self.sync.peers().into_iter().map(Into::into).collect();

        Ok(Peers {
            active: sync_status.num_active_peers,
            connected: sync_status.num_peers,
            max: sync_status.current_max_peers(*num_peers_range.start(), *num_peers_range.end()),
            peers,
        })
    }

    fn net_port(&self) -> Result<u16> {
        Ok(self.settings.network_port)
    }

    fn node_name(&self) -> Result<String> {
        Ok(self.settings.name.clone())
    }

    fn registry_address(&self) -> Result<Option<H160>> {
        Ok(self
            .client
            .additional_params()
            .get("registrar")
            .and_then(|s| Address::from_str(s).ok()))
    }

    fn rpc_settings(&self) -> Result<RpcSettings> {
        Ok(RpcSettings {
            enabled: self.settings.rpc_enabled,
            interface: self.settings.rpc_interface.clone(),
            port: self.settings.rpc_port as u64,
        })
    }

    fn default_extra_data(&self) -> Result<Bytes> {
        Ok(Bytes::new(version_data()))
    }

    fn gas_price_histogram(&self) -> BoxFuture<Histogram> {
        Box::new(future::done(
            self.client
                .gas_price_corpus(100)
                .histogram(10)
                .ok_or_else(errors::not_enough_data)
                .map(Into::into),
        ))
    }

    fn unsigned_transactions_count(&self) -> Result<usize> {
        match self.signer {
            None => Err(errors::signer_disabled()),
            Some(ref signer) => Ok(signer.len()),
        }
    }

    fn generate_secret_phrase(&self) -> Result<String> {
        Ok(random_phrase(12))
    }

    fn phrase_to_address(&self, phrase: String) -> Result<H160> {
        Ok(Brain::new(phrase)
            .generate()
            .expect("Brain::generate always returns Ok; qed")
            .address())
    }

    fn list_accounts(
        &self,
        count: u64,
        after: Option<H160>,
        block_number: Option<BlockNumber>,
    ) -> Result<Option<Vec<H160>>> {
        let number = match block_number.unwrap_or_default() {
            BlockNumber::Pending => {
                warn!("BlockNumber::Pending is unsupported");
                return Ok(None);
            }

            num => block_number_to_id(num),
        };

        Ok(self
            .client
            .list_accounts(number, after.map(Into::into).as_ref(), count)
            .map(|a| a.into_iter().map(Into::into).collect()))
    }

    fn list_storage_keys(
        &self,
        address: H160,
        count: u64,
        after: Option<H256>,
        block_number: Option<BlockNumber>,
    ) -> Result<Option<Vec<H256>>> {
        let number = match block_number.unwrap_or_default() {
            BlockNumber::Pending => {
                warn!("BlockNumber::Pending is unsupported");
                return Ok(None);
            }

            num => block_number_to_id(num),
        };

        Ok(self
            .client
            .list_storage(number, &address, after.map(Into::into).as_ref(), count)
            .map(|a| a.into_iter().map(Into::into).collect()))
    }

    fn encrypt_message(&self, key: H512, phrase: Bytes) -> Result<Bytes> {
        ecies::encrypt(&key, &DEFAULT_MAC, &phrase.0)
            .map_err(errors::encryption)
            .map(Into::into)
    }

    fn pending_transactions(&self, limit: Option<usize>) -> Result<Vec<Transaction>> {
        let ready_transactions = self.miner.ready_transactions(
            &*self.client,
            limit.unwrap_or_else(usize::max_value),
            miner::PendingOrdering::Priority,
        );

        Ok(ready_transactions
            .into_iter()
            .map(|t| Transaction::from_pending(t.pending().clone()))
            .collect())
    }

    fn all_transactions(&self) -> Result<Vec<Transaction>> {
        let all_transactions = self.miner.queued_transactions();

        Ok(all_transactions
            .into_iter()
            .map(|t| Transaction::from_pending(t.pending().clone()))
            .collect())
    }

    fn all_transaction_hashes(&self) -> Result<Vec<H256>> {
        Ok(self.miner.queued_transaction_hashes())
    }

    fn future_transactions(&self) -> Result<Vec<Transaction>> {
        Err(errors::deprecated("Use `parity_allTransaction` instead."))
    }

    fn pending_transactions_stats(&self) -> Result<BTreeMap<H256, TransactionStats>> {
        let stats = self.sync.transactions_stats();
        Ok(stats
            .into_iter()
            .map(|(hash, stats)| (hash, stats.into()))
            .collect())
    }

    fn local_transactions(&self) -> Result<BTreeMap<H256, LocalTransactionStatus>> {
        let transactions = self.miner.local_transactions();
        Ok(transactions
            .into_iter()
            .map(|(hash, status)| (hash, LocalTransactionStatus::from(status)))
            .collect())
    }

    fn ws_url(&self) -> Result<String> {
        helpers::to_url(&self.ws_address).ok_or_else(errors::ws_disabled)
    }

    fn next_nonce(&self, address: H160) -> BoxFuture<U256> {
        Box::new(future::ok(self.miner.next_nonce(&*self.client, &address)))
    }

    fn mode(&self) -> Result<String> {
        Ok(self.client.mode().to_string())
    }

    fn enode(&self) -> Result<String> {
        self.sync.enode().ok_or_else(errors::network_disabled)
    }

    fn chain_status(&self) -> Result<ChainStatus> {
        let chain_info = self.client.chain_info();

        let gap = chain_info
            .ancient_block_number
            .map(|x| U256::from(x + 1))
            .and_then(|first| {
                chain_info
                    .first_block_number
                    .map(|last| (first, U256::from(last)))
            });

        Ok(ChainStatus { block_gap: gap })
    }

    fn node_kind(&self) -> Result<::v1::types::NodeKind> {
        use v1::types::{Availability, Capability, NodeKind};

        Ok(NodeKind {
            availability: Availability::Personal,
            capability: Capability::Full,
        })
    }

    fn block_header(&self, number: Option<BlockNumber>) -> BoxFuture<RichHeader> {
        const EXTRA_INFO_PROOF: &str = "Object exists in blockchain (fetched earlier), extra_info is always available if object exists; qed";
        let number = number.unwrap_or_default();

        let (header, extra) = if number == BlockNumber::Pending {
            let info = self.client.chain_info();
            let header = try_bf!(self
                .miner
                .pending_block_header(info.best_block_number)
                .ok_or_else(errors::unknown_block));

            (header.encoded(), None)
        } else {
            let id = match number {
                BlockNumber::Num(num) => BlockId::Number(num),
                BlockNumber::Earliest => BlockId::Earliest,
                BlockNumber::Latest => BlockId::Latest,
                BlockNumber::Pending => unreachable!(), // Already covered
            };

            let header = try_bf!(self
                .client
                .block_header(id)
                .ok_or_else(errors::unknown_block));
            let info = self.client.block_extra_info(id).expect(EXTRA_INFO_PROOF);

            (header, Some(info))
        };

        Box::new(future::ok(RichHeader {
            inner: header.into(),
            extra_info: extra.unwrap_or_default(),
        }))
    }

    fn block_receipts(&self, number: Option<BlockNumber>) -> BoxFuture<Vec<Receipt>> {
        let number = number.unwrap_or_default();

        let id = match number {
            BlockNumber::Pending => {
                let info = self.client.chain_info();
                let receipts = try_bf!(self
                    .miner
                    .pending_receipts(info.best_block_number)
                    .ok_or_else(errors::unknown_block));
                return Box::new(future::ok(receipts.into_iter().map(Into::into).collect()));
            }
            BlockNumber::Num(num) => BlockId::Number(num),
            BlockNumber::Earliest => BlockId::Earliest,
            BlockNumber::Latest => BlockId::Latest,
        };
        let receipts = try_bf!(self
            .client
            .localized_block_receipts(id)
            .ok_or_else(errors::unknown_block));
        Box::new(future::ok(receipts.into_iter().map(Into::into).collect()))
    }

    fn call(&self, requests: Vec<CallRequest>, num: Option<BlockNumber>) -> Result<Vec<Bytes>> {
        let requests = requests
            .into_iter()
            .map(|request| Ok((fake_sign::sign_call(request.into())?, Default::default())))
            .collect::<Result<Vec<_>>>()?;

        let num = num.unwrap_or_default();

        let (mut state, header) = if num == BlockNumber::Pending {
            let info = self.client.chain_info();
            let state = self
                .miner
                .pending_state(info.best_block_number)
                .ok_or_else(errors::state_pruned)?;
            let header = self
                .miner
                .pending_block_header(info.best_block_number)
                .ok_or_else(errors::state_pruned)?;

            (state, header)
        } else {
            let id = match num {
                BlockNumber::Num(num) => BlockId::Number(num),
                BlockNumber::Earliest => BlockId::Earliest,
                BlockNumber::Latest => BlockId::Latest,
                BlockNumber::Pending => unreachable!(), // Already covered
            };

            let state = self.client.state_at(id).ok_or_else(errors::state_pruned)?;
            let header = self
                .client
                .block_header(id)
                .ok_or_else(errors::state_pruned)?
                .decode()
                .map_err(errors::decode)?;

            (state, header)
        };

        self.client
            .call_many(&requests, &mut state, &header)
            .map(|res| res.into_iter().map(|res| res.output.into()).collect())
            .map_err(errors::call)
    }

    fn submit_work_detail(&self, nonce: H64, pow_hash: H256, mix_hash: H256) -> Result<H256> {
        helpers::submit_work_detail(&self.client, &self.miner, nonce, pow_hash, mix_hash)
    }

    fn status(&self) -> Result<()> {
        let has_peers = self.settings.is_dev_chain || self.sync.status().num_peers > 0;
        let is_warping = match self.snapshot.as_ref().map(|s| s.restoration_status()) {
            Some(RestorationStatus::Ongoing { .. }) => true,
            _ => false,
        };
        let is_not_syncing = !is_warping
            && !is_major_importing(Some(self.sync.status().state), self.client.queue_info());

        if has_peers && is_not_syncing {
            Ok(())
        } else {
            Err(errors::status_error(has_peers))
        }
    }

    fn verify_signature(
        &self,
        is_prefixed: bool,
        message: Bytes,
        r: H256,
        s: H256,
        v: U64,
    ) -> Result<RecoveredAccount> {
        verify_signature(
            is_prefixed,
            message,
            r,
            s,
            v,
            self.client.signing_chain_id(),
        )
    }
}