2018-06-04 10:19:50 +02:00
|
|
|
// Copyright 2015-2018 Parity Technologies (UK) Ltd.
|
2016-04-11 21:06:32 +02:00
|
|
|
// 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/>.
|
|
|
|
|
|
|
|
use std::sync::Arc;
|
2016-11-06 12:51:53 +01:00
|
|
|
use ethcore::account_provider::AccountProvider;
|
2018-09-25 19:06:14 +02:00
|
|
|
use ethcore::client::{TestBlockChainClient, Executed, TransactionId};
|
2017-08-28 14:11:55 +02:00
|
|
|
use ethcore_logger::RotatingLogger;
|
2018-04-13 17:34:27 +02:00
|
|
|
use ethereum_types::{Address, U256, H256};
|
2016-10-15 14:44:08 +02:00
|
|
|
use ethstore::ethkey::{Generator, Random};
|
2018-04-13 17:34:27 +02:00
|
|
|
use miner::pool::local_transactions::Status as LocalTransactionStatus;
|
|
|
|
use sync::ManageNetwork;
|
2019-01-04 14:05:46 +01:00
|
|
|
use types::receipt::{LocalizedReceipt, TransactionOutcome};
|
2016-08-11 17:19:20 +02:00
|
|
|
|
2017-01-11 20:02:27 +01:00
|
|
|
use jsonrpc_core::IoHandler;
|
2016-11-06 12:51:53 +01:00
|
|
|
use v1::{Parity, ParityClient};
|
2017-01-30 11:10:58 +01:00
|
|
|
use v1::metadata::Metadata;
|
2016-09-21 12:44:49 +02:00
|
|
|
use v1::helpers::{SignerService, NetworkSettings};
|
2016-12-12 03:49:50 +01:00
|
|
|
use v1::tests::helpers::{TestSyncProvider, Config, TestMinerService, TestUpdater};
|
2016-08-11 17:19:20 +02:00
|
|
|
use super::manage_network::TestManageNetwork;
|
2017-09-21 14:52:44 +02:00
|
|
|
use Host;
|
2016-04-11 21:06:32 +02:00
|
|
|
|
2017-08-28 14:11:55 +02:00
|
|
|
pub type TestParityClient = ParityClient<TestBlockChainClient, TestMinerService, TestUpdater>;
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-10-24 12:21:15 +02:00
|
|
|
pub struct Dependencies {
|
|
|
|
pub miner: Arc<TestMinerService>,
|
|
|
|
pub client: Arc<TestBlockChainClient>,
|
|
|
|
pub sync: Arc<TestSyncProvider>,
|
2016-12-12 03:49:50 +01:00
|
|
|
pub updater: Arc<TestUpdater>,
|
2016-10-24 12:21:15 +02:00
|
|
|
pub logger: Arc<RotatingLogger>,
|
|
|
|
pub settings: Arc<NetworkSettings>,
|
|
|
|
pub network: Arc<ManageNetwork>,
|
2016-11-06 12:51:53 +01:00
|
|
|
pub accounts: Arc<AccountProvider>,
|
2017-09-21 14:52:44 +02:00
|
|
|
pub ws_address: Option<Host>,
|
2016-08-11 17:19:20 +02:00
|
|
|
}
|
|
|
|
|
2016-10-24 12:21:15 +02:00
|
|
|
impl Dependencies {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Dependencies {
|
|
|
|
miner: Arc::new(TestMinerService::default()),
|
|
|
|
client: Arc::new(TestBlockChainClient::default()),
|
|
|
|
sync: Arc::new(TestSyncProvider::new(Config {
|
2016-11-03 22:22:25 +01:00
|
|
|
network_id: 3,
|
2016-10-24 12:21:15 +02:00
|
|
|
num_peers: 120,
|
|
|
|
})),
|
2016-12-12 03:49:50 +01:00
|
|
|
updater: Arc::new(TestUpdater::default()),
|
2016-10-24 12:21:15 +02:00
|
|
|
logger: Arc::new(RotatingLogger::new("rpc=trace".to_owned())),
|
|
|
|
settings: Arc::new(NetworkSettings {
|
|
|
|
name: "mynode".to_owned(),
|
|
|
|
chain: "testchain".to_owned(),
|
2018-11-07 09:30:34 +01:00
|
|
|
is_dev_chain: false,
|
2016-10-24 12:21:15 +02:00
|
|
|
network_port: 30303,
|
|
|
|
rpc_enabled: true,
|
|
|
|
rpc_interface: "all".to_owned(),
|
|
|
|
rpc_port: 8545,
|
|
|
|
}),
|
|
|
|
network: Arc::new(TestManageNetwork),
|
2016-11-06 12:51:53 +01:00
|
|
|
accounts: Arc::new(AccountProvider::transient_provider()),
|
2017-09-21 14:52:44 +02:00
|
|
|
ws_address: Some("127.0.0.1:18546".into()),
|
2016-10-24 12:21:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
pub fn client(&self, signer: Option<Arc<SignerService>>) -> TestParityClient {
|
|
|
|
ParityClient::new(
|
2017-08-28 14:11:55 +02:00
|
|
|
self.client.clone(),
|
|
|
|
self.miner.clone(),
|
|
|
|
self.sync.clone(),
|
|
|
|
self.updater.clone(),
|
|
|
|
self.network.clone(),
|
2018-06-04 11:26:30 +02:00
|
|
|
self.accounts.clone(),
|
2016-10-24 12:21:15 +02:00
|
|
|
self.logger.clone(),
|
|
|
|
self.settings.clone(),
|
|
|
|
signer,
|
2017-05-24 12:24:07 +02:00
|
|
|
self.ws_address.clone(),
|
2018-11-07 09:30:34 +01:00
|
|
|
None,
|
2016-10-24 12:21:15 +02:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2017-01-30 11:10:58 +01:00
|
|
|
fn default_client(&self) -> IoHandler<Metadata> {
|
2017-01-11 20:02:27 +01:00
|
|
|
let mut io = IoHandler::default();
|
|
|
|
io.extend_with(self.client(None).to_delegate());
|
2016-10-24 12:21:15 +02:00
|
|
|
io
|
|
|
|
}
|
|
|
|
|
2017-01-30 11:10:58 +01:00
|
|
|
fn with_signer(&self, signer: SignerService) -> IoHandler<Metadata> {
|
2017-01-11 20:02:27 +01:00
|
|
|
let mut io = IoHandler::default();
|
|
|
|
io.extend_with(self.client(Some(Arc::new(signer))).to_delegate());
|
2016-10-24 12:21:15 +02:00
|
|
|
io
|
|
|
|
}
|
2016-06-07 22:52:48 +02:00
|
|
|
}
|
|
|
|
|
2016-12-12 03:49:50 +01:00
|
|
|
#[test]
|
2016-12-23 18:52:02 +01:00
|
|
|
fn rpc_parity_accounts_info() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
2018-06-22 15:09:15 +02:00
|
|
|
deps.accounts.new_account(&"".into()).unwrap();
|
2016-12-23 18:52:02 +01:00
|
|
|
let accounts = deps.accounts.accounts().unwrap();
|
|
|
|
assert_eq!(accounts.len(), 1);
|
|
|
|
let address = accounts[0];
|
|
|
|
|
2017-02-20 16:33:12 +01:00
|
|
|
deps.accounts.set_address_name(1.into(), "XX".into());
|
|
|
|
deps.accounts.set_account_name(address.clone(), "Test".into()).unwrap();
|
|
|
|
deps.accounts.set_account_meta(address.clone(), "{foo: 69}".into()).unwrap();
|
2016-12-23 18:52:02 +01:00
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_accountsInfo", "params": [], "id": 1}"#;
|
2018-02-09 09:32:06 +01:00
|
|
|
let response = format!("{{\"jsonrpc\":\"2.0\",\"result\":{{\"0x{:x}\":{{\"name\":\"Test\"}}}},\"id\":1}}", address);
|
2016-12-23 18:52:02 +01:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response));
|
|
|
|
}
|
|
|
|
|
2017-01-30 11:10:58 +01:00
|
|
|
#[test]
|
|
|
|
fn rpc_parity_default_account() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
// Check empty
|
|
|
|
let address = Address::default();
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_defaultAccount", "params": [], "id": 1}"#;
|
2018-02-09 09:32:06 +01:00
|
|
|
let response = format!("{{\"jsonrpc\":\"2.0\",\"result\":\"0x{:x}\",\"id\":1}}", address);
|
2017-01-30 11:10:58 +01:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response));
|
|
|
|
|
|
|
|
// With account
|
2018-06-22 15:09:15 +02:00
|
|
|
deps.accounts.new_account(&"".into()).unwrap();
|
2017-01-30 11:10:58 +01:00
|
|
|
let accounts = deps.accounts.accounts().unwrap();
|
|
|
|
assert_eq!(accounts.len(), 1);
|
|
|
|
let address = accounts[0];
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_defaultAccount", "params": [], "id": 1}"#;
|
2018-02-09 09:32:06 +01:00
|
|
|
let response = format!("{{\"jsonrpc\":\"2.0\",\"result\":\"0x{:x}\",\"id\":1}}", address);
|
2017-01-30 11:10:58 +01:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response));
|
|
|
|
}
|
|
|
|
|
2016-12-23 18:52:02 +01:00
|
|
|
#[test]
|
2016-12-12 03:49:50 +01:00
|
|
|
fn rpc_parity_consensus_capability() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_consensusCapability", "params": [], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"capableUntil":15100},"id":1}"#;
|
2016-12-12 04:29:55 +01:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
|
|
|
|
deps.updater.set_current_block(15101);
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_consensusCapability", "params": [], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"incapableSince":15100},"id":1}"#;
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
|
|
|
|
deps.updater.set_updated(true);
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_consensusCapability", "params": [], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"capable","id":1}"#;
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_version_info() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_versionInfo", "params": [], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"hash":"0x0000000000000000000000000000000000000096","track":"beta","version":{"major":1,"minor":5,"patch":0}},"id":1}"#;
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_releases_info() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-12-12 03:49:50 +01:00
|
|
|
|
2016-12-12 04:29:55 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_releasesInfo", "params": [], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"fork":15100,"minor":null,"this_fork":15000,"track":{"binary":"0x00000000000000000000000000000000000000000000000000000000000005e6","fork":15100,"is_critical":true,"version":{"hash":"0x0000000000000000000000000000000000000097","track":"beta","version":{"major":1,"minor":5,"patch":1}}}},"id":1}"#;
|
2016-12-12 03:49:50 +01:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
2016-04-11 21:06:32 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_extra_data() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-11 21:06:32 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_extraData", "params": [], "id": 1}"#;
|
2016-04-11 21:06:32 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"0x01020304","id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-11 21:06:32 +02:00
|
|
|
}
|
|
|
|
|
2016-05-08 22:34:15 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_default_extra_data() {
|
2017-12-22 14:37:39 +01:00
|
|
|
use version::version_data;
|
2017-09-06 20:47:45 +02:00
|
|
|
use bytes::ToPretty;
|
2016-05-08 22:34:15 +02:00
|
|
|
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-05-08 22:34:15 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_defaultExtraData", "params": [], "id": 1}"#;
|
2017-12-22 14:37:39 +01:00
|
|
|
let response = format!(r#"{{"jsonrpc":"2.0","result":"0x{}","id":1}}"#, version_data().to_hex());
|
2016-05-08 22:34:15 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response));
|
2016-05-08 22:34:15 +02:00
|
|
|
}
|
2016-04-11 21:06:32 +02:00
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_gas_floor_target() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-11 21:06:32 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_gasFloorTarget", "params": [], "id": 1}"#;
|
2016-04-11 21:06:32 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"0x3039","id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-11 21:06:32 +02:00
|
|
|
}
|
|
|
|
|
2016-04-13 00:04:40 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_min_gas_price() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-13 00:04:40 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_minGasPrice", "params": [], "id": 1}"#;
|
2016-09-02 11:38:16 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"0x1312d00","id":1}"#;
|
2016-04-13 00:04:40 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-13 00:04:40 +02:00
|
|
|
}
|
|
|
|
|
2016-04-19 19:08:13 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_dev_logs() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
deps.logger.append("a".to_owned());
|
|
|
|
deps.logger.append("b".to_owned());
|
|
|
|
|
|
|
|
let io = deps.default_client();
|
2016-04-19 19:08:13 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_devLogs", "params":[], "id": 1}"#;
|
2016-04-19 19:08:13 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":["b","a"],"id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-19 19:08:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_dev_logs_levels() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-19 19:08:13 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_devLogsLevels", "params":[], "id": 1}"#;
|
2016-04-19 19:08:13 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"rpc=trace","id":1}"#;
|
2016-04-18 23:13:38 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-19 19:38:41 +02:00
|
|
|
}
|
|
|
|
|
2016-04-18 23:13:38 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_transactions_limit() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-18 23:13:38 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_transactionsLimit", "params":[], "id": 1}"#;
|
2016-04-18 23:13:38 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":1024,"id":1}"#;
|
2016-04-19 19:08:13 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-19 19:08:13 +02:00
|
|
|
}
|
2016-04-21 19:19:42 +02:00
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_net_chain() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_netChain", "params":[], "id": 1}"#;
|
2016-04-21 19:19:42 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"testchain","id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-21 19:19:42 +02:00
|
|
|
}
|
|
|
|
|
2017-03-13 12:10:53 +01:00
|
|
|
#[test]
|
|
|
|
fn rpc_parity_chain() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_chain", "params":[], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"foundation","id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
2016-04-21 19:19:42 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_net_peers() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_netPeers", "params":[], "id": 1}"#;
|
2018-07-11 13:35:10 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"active":0,"connected":120,"max":50,"peers":[{"caps":["eth/62","eth/63"],"id":"node1","name":"Parity-Ethereum/1","network":{"localAddress":"127.0.0.1:8888","remoteAddress":"127.0.0.1:7777"},"protocols":{"eth":{"difficulty":"0x28","head":"0000000000000000000000000000000000000000000000000000000000000032","version":62},"pip":null}},{"caps":["eth/63","eth/64"],"id":null,"name":"Parity-Ethereum/2","network":{"localAddress":"127.0.0.1:3333","remoteAddress":"Handshake"},"protocols":{"eth":{"difficulty":null,"head":"000000000000000000000000000000000000000000000000000000000000003c","version":64},"pip":null}}]},"id":1}"#;
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-21 19:19:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_net_port() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_netPort", "params":[], "id": 1}"#;
|
2016-04-21 19:19:42 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":30303,"id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-21 19:19:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_rpc_settings() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_rpcSettings", "params":[], "id": 1}"#;
|
2016-04-21 19:19:42 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"enabled":true,"interface":"all","port":8545},"id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-21 19:19:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_node_name() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-04-21 19:19:42 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_nodeName", "params":[], "id": 1}"#;
|
2016-04-21 19:19:42 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"mynode","id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-04-21 19:19:42 +02:00
|
|
|
}
|
2016-06-21 14:55:25 +02:00
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_unsigned_transactions_count() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
2017-05-24 12:24:07 +02:00
|
|
|
let io = deps.with_signer(SignerService::new_test(true));
|
2016-06-21 14:55:25 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_unsignedTransactionsCount", "params":[], "id": 1}"#;
|
2016-06-21 14:55:25 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":0,"id":1}"#;
|
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-06-21 14:55:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_unsigned_transactions_count_when_signer_disabled() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-06-21 14:55:25 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_unsignedTransactionsCount", "params":[], "id": 1}"#;
|
2017-03-22 07:02:14 +01:00
|
|
|
let response = r#"{"jsonrpc":"2.0","error":{"code":-32000,"message":"Trusted Signer is disabled. This API is not available."},"id":1}"#;
|
2016-06-21 14:55:25 +02:00
|
|
|
|
2016-09-01 12:00:00 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-06-21 14:55:25 +02:00
|
|
|
}
|
2016-09-23 18:13:03 +02:00
|
|
|
|
2016-09-27 16:27:06 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_pending_transactions() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2016-09-23 18:13:03 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_pendingTransactions", "params":[], "id": 1}"#;
|
2016-09-23 18:13:03 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":[],"id":1}"#;
|
|
|
|
|
2016-09-26 12:24:52 +02:00
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
2016-09-23 18:13:03 +02:00
|
|
|
}
|
2016-10-15 14:44:08 +02:00
|
|
|
|
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_encrypt() {
|
2016-10-24 12:21:15 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2018-04-02 13:12:52 +02:00
|
|
|
let key = format!("{:x}", Random.generate().unwrap().public());
|
2016-10-15 14:44:08 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_encryptMessage", "params":["0x"#.to_owned() + &key + r#"", "0x01"], "id": 1}"#;
|
2016-10-15 14:44:08 +02:00
|
|
|
assert!(io.handle_request_sync(&request).unwrap().contains("result"), "Should return success.");
|
|
|
|
}
|
2016-10-24 12:21:15 +02:00
|
|
|
|
|
|
|
#[test]
|
2017-05-24 12:24:07 +02:00
|
|
|
fn rpc_parity_ws_address() {
|
2016-10-24 12:21:15 +02:00
|
|
|
// given
|
|
|
|
let mut deps = Dependencies::new();
|
|
|
|
let io1 = deps.default_client();
|
2017-05-24 12:24:07 +02:00
|
|
|
deps.ws_address = None;
|
2016-10-24 12:21:15 +02:00
|
|
|
let io2 = deps.default_client();
|
|
|
|
|
|
|
|
// when
|
2017-05-24 12:24:07 +02:00
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_wsUrl", "params": [], "id": 1}"#;
|
|
|
|
let response1 = r#"{"jsonrpc":"2.0","result":"127.0.0.1:18546","id":1}"#;
|
|
|
|
let response2 = r#"{"jsonrpc":"2.0","error":{"code":-32000,"message":"WebSockets Server is disabled. This API is not available."},"id":1}"#;
|
2016-11-09 19:41:47 +01:00
|
|
|
|
|
|
|
// then
|
|
|
|
assert_eq!(io1.handle_request_sync(request), Some(response1.to_owned()));
|
|
|
|
assert_eq!(io2.handle_request_sync(request), Some(response2.to_owned()));
|
|
|
|
}
|
|
|
|
|
2016-10-27 19:29:55 +02:00
|
|
|
#[test]
|
2016-11-06 12:51:53 +01:00
|
|
|
fn rpc_parity_next_nonce() {
|
2016-10-27 19:29:55 +02:00
|
|
|
let deps = Dependencies::new();
|
|
|
|
let address = Address::default();
|
|
|
|
let io1 = deps.default_client();
|
|
|
|
let deps = Dependencies::new();
|
2018-04-13 17:34:27 +02:00
|
|
|
deps.miner.increment_nonce(&address);
|
|
|
|
deps.miner.increment_nonce(&address);
|
|
|
|
deps.miner.increment_nonce(&address);
|
2016-10-27 19:29:55 +02:00
|
|
|
let io2 = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
2016-11-06 12:51:53 +01:00
|
|
|
"method": "parity_nextNonce",
|
2018-04-02 13:12:52 +02:00
|
|
|
"params": [""#.to_owned() + &format!("0x{:x}", address) + r#""],
|
2016-10-27 19:29:55 +02:00
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response1 = r#"{"jsonrpc":"2.0","result":"0x0","id":1}"#;
|
|
|
|
let response2 = r#"{"jsonrpc":"2.0","result":"0x3","id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io1.handle_request_sync(&request), Some(response1.to_owned()));
|
|
|
|
assert_eq!(io2.handle_request_sync(&request), Some(response2.to_owned()));
|
|
|
|
}
|
2016-11-16 13:37:21 +01:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_transactions_stats() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_pendingTransactionsStats", "params":[], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"0x0000000000000000000000000000000000000000000000000000000000000001":{"firstSeen":10,"propagatedTo":{"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080":16}},"0x0000000000000000000000000000000000000000000000000000000000000005":{"firstSeen":16,"propagatedTo":{"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010":1}}},"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
2016-11-16 17:54:54 +01:00
|
|
|
#[test]
|
|
|
|
fn rpc_parity_local_transactions() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
2019-01-04 14:05:46 +01:00
|
|
|
let tx = ::types::transaction::Transaction {
|
2018-04-13 17:34:27 +02:00
|
|
|
value: 5.into(),
|
|
|
|
gas: 3.into(),
|
|
|
|
gas_price: 2.into(),
|
2019-01-04 14:05:46 +01:00
|
|
|
action: ::types::transaction::Action::Create,
|
2018-04-13 17:34:27 +02:00
|
|
|
data: vec![1, 2, 3],
|
|
|
|
nonce: 0.into(),
|
|
|
|
}.fake_sign(3.into());
|
|
|
|
let tx = Arc::new(::miner::pool::VerifiedTransaction::from_pending_block_transaction(tx));
|
|
|
|
deps.miner.local_transactions.lock().insert(10.into(), LocalTransactionStatus::Pending(tx.clone()));
|
|
|
|
deps.miner.local_transactions.lock().insert(15.into(), LocalTransactionStatus::Pending(tx.clone()));
|
2016-11-16 17:54:54 +01:00
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_localTransactions", "params":[], "id": 1}"#;
|
2018-04-13 17:34:27 +02:00
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"0x000000000000000000000000000000000000000000000000000000000000000a":{"status":"pending"},"0x000000000000000000000000000000000000000000000000000000000000000f":{"status":"pending"}},"id":1}"#;
|
2016-11-16 17:54:54 +01:00
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
2016-12-19 15:27:17 +01:00
|
|
|
#[test]
|
|
|
|
fn rpc_parity_chain_status() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
*deps.client.ancient_block.write() = Some((H256::default(), 5));
|
|
|
|
*deps.client.first_block.write() = Some((H256::from(U256::from(1234)), 3333));
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_chainStatus", "params":[], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"blockGap":["0x6","0xd05"]},"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2017-03-27 17:30:19 +02:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_node_kind() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_nodeKind", "params":[], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"availability":"personal","capability":"full"},"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2017-04-08 13:35:23 +02:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_cid() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{"jsonrpc": "2.0", "method": "parity_cidV0", "params":["0x414243"], "id": 1}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":"QmSF59MAENc8ZhM4aM1thuAE8w5gDmyfzkAvNoyPea7aDz","id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2017-08-04 15:58:14 +02:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_call() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
deps.client.set_execution_result(Ok(Executed {
|
|
|
|
exception: None,
|
|
|
|
gas: U256::zero(),
|
|
|
|
gas_used: U256::from(0xff30),
|
|
|
|
refunded: U256::from(0x5),
|
|
|
|
cumulative_gas_used: U256::zero(),
|
|
|
|
logs: vec![],
|
|
|
|
contracts_created: vec![],
|
|
|
|
output: vec![0x12, 0x34, 0xff],
|
|
|
|
trace: vec![],
|
|
|
|
vm_trace: None,
|
|
|
|
state_diff: None,
|
|
|
|
}));
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_call",
|
|
|
|
"params": [[{
|
|
|
|
"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
|
|
|
|
"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
|
|
|
|
"gas": "0x76c0",
|
|
|
|
"gasPrice": "0x9184e72a000",
|
|
|
|
"value": "0x9184e72a",
|
|
|
|
"data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
|
|
|
|
}],
|
|
|
|
"latest"],
|
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":["0x1234ff"],"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2018-09-25 19:06:14 +02:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_block_receipts() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
deps.client.receipts.write()
|
|
|
|
.insert(TransactionId::Hash(1.into()), LocalizedReceipt {
|
|
|
|
transaction_hash: 1.into(),
|
|
|
|
transaction_index: 0,
|
|
|
|
block_hash: 3.into(),
|
|
|
|
block_number: 0,
|
|
|
|
cumulative_gas_used: 21_000.into(),
|
|
|
|
gas_used: 21_000.into(),
|
|
|
|
contract_address: None,
|
|
|
|
logs: vec![],
|
|
|
|
log_bloom: 1.into(),
|
|
|
|
outcome: TransactionOutcome::Unknown,
|
|
|
|
to: None,
|
|
|
|
from: 9.into(),
|
|
|
|
});
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_getBlockReceipts",
|
|
|
|
"params": [],
|
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":[{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000003","blockNumber":"0x0","contractAddress":null,"cumulativeGasUsed":"0x5208","from":"0x0000000000000000000000000000000000000009","gasUsed":"0x5208","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001","root":null,"status":null,"to":null,"transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000001","transactionIndex":"0x0"}],"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2018-11-07 09:30:34 +01:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_status_ok() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_nodeStatus",
|
|
|
|
"params": [],
|
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":null,"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_status_error_peers() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
deps.sync.status.write().num_peers = 0;
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_nodeStatus",
|
|
|
|
"params": [],
|
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","error":{"code":-32066,"message":"Node is not connected to any peers."},"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_status_error_sync() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
deps.sync.status.write().state = ::sync::SyncState::Blocks;
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_nodeStatus",
|
|
|
|
"params": [],
|
|
|
|
"id": 1
|
|
|
|
}"#;
|
|
|
|
let response = r#"{"jsonrpc":"2.0","error":{"code":-32001,"message":"Still syncing."},"id":1}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|
2018-11-28 12:18:43 +01:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn rpc_parity_verify_signature() {
|
|
|
|
let deps = Dependencies::new();
|
|
|
|
let io = deps.default_client();
|
|
|
|
|
|
|
|
let request = r#"{
|
|
|
|
"jsonrpc": "2.0",
|
|
|
|
"method": "parity_verifySignature",
|
|
|
|
"params": [
|
|
|
|
false,
|
|
|
|
"0xe552acf4caabe9661893fd48c7b5e68af20bf007193442f8ca05ce836699d75e",
|
|
|
|
"0x2089e84151c3cdc45255c07557b349f5bf2ed3e68f6098723eaa90a0f8b2b3e5",
|
|
|
|
"0x5f70e8df7bd0c4417afb5f5a39d82e15d03adeff8796725d8b14889ed1d1aa8a",
|
|
|
|
"0x1"
|
|
|
|
],
|
|
|
|
"id": 0
|
|
|
|
}"#;
|
|
|
|
|
|
|
|
let response = r#"{"jsonrpc":"2.0","result":{"address":"0x9a2a08a1170f51208c2f3cede0d29ada94481eed","isValidForCurrentChain":true,"publicKey":"0xbeec94ea24444906fe247c47841a45220f07e5718d06157fe4502fac326dab617e973e221e45746721330c2db3f63202268686378cc28b9800c1daaf0bbafeb1"},"id":0}"#;
|
|
|
|
|
|
|
|
assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
|
|
|
|
}
|