2.4.4 more beta backports (#10554)

* fix(rpc-types): replace uint and hash with `ethereum_types v0.4` (#10217)

* fix(rpc-types): remove uint and hash wrappers

* fix(tests)

* fix(cleanup)

* grumbles(rpc-api): revert `verify_signature`

* revert change of `U64` -> `u64`

* fix(cleanup after bad merge)

* chore(bump ethereum-types)

* fix(bad merge)

* feat(tests ethereum-types): add tests

* chore(update `ethereum-types` to 0.4.2)

* feat(tests for h256)

* chore(rpc): remove `ethbloom` import

Use re-export from `ethereum-types` instead

* fix(bad merge): remove `DefaultAccount` type

* doc(add TODO with issue link)

* chore(bump ethereum-types) (#10396)

Fixes a de-serialization bug in `ethereum-tyes`

* fix(light eth_gasPrice): ask network if not in cache (#10535)

* fix(light eth_gasPrice): ask N/W if not in cache

* fix(bad rebase)

* fix(light account response): update `tx_queue` (#10545)

* fix(bump dependencies) (#10540)

* cargo update -p log:0.4.5

* cargo update -p regex:1.0.5

* cargo update -p parking_lot

* cargo update -p serde_derive

* cargo update -p serde_json

* cargo update -p serde

* cargo update -p lazy_static

* cargo update -p num_cpus

* cargo update -p toml

# Conflicts:
#	Cargo.lock

* tx-pool: check transaction readiness before replacing (#10526)

* Update to vanilla tx pool error

* Prevent a non ready tx replacing a ready tx

* Make tests compile

* Test ready tx not replaced by future tx

* Transaction indirection

* Use StateReadiness to calculate Ready in `should_replace`

* Test existing txs from same sender are used to compute Readiness

* private-tx: Wire up ShouldReplace

* Revert "Use StateReadiness to calculate Ready in `should_replace`"

This reverts commit af9e69c

* Make replace generic so it works with private-tx

* Rename Replace and add missing docs

* ShouldReplace no longer mutable

* tx-pool: update to transaction-pool 2.0 from crates.io

* tx-pool: generic error type alias

* Exit early for first unmatching nonce

* Fix private-tx test, use existing write lock

* Use read lock for pool scoring

* fix #10390 (#10391)

* private-tx: replace error_chain (#10510)

* Update to vanilla tx pool error

* private-tx: remove error-chain, implement Error, derive Display

* private-tx: replace ErrorKind and bail!

* private-tx: add missing From impls and other compiler errors

* private-tx: use original tx-pool error

* Don't be silly cargo

cli-signer/Cargo.toml

@@ -7,6 +7,7 @@ name = "cli-signer"
 version = "1.4.0"
 
 [dependencies]
+ethereum-types = "0.4"
 futures = "0.1"
 rpassword = "1.0"
 parity-rpc = { path = "../rpc" }

cli-signer/rpc-client/Cargo.toml

@@ -7,6 +7,7 @@ name = "parity-rpc-client"
 version = "1.4.0"
 
 [dependencies]
+ethereum-types = "0.4"
 futures = "0.1"
 log = "0.4"
 serde = "1.0"

cli-signer/rpc-client/src/lib.rs

@@ -17,6 +17,7 @@
 pub mod client;
 pub mod signer_client;
 
+extern crate ethereum_types;
 extern crate futures;
 extern crate jsonrpc_core;
 extern crate jsonrpc_ws_server as ws;

cli-signer/rpc-client/src/signer_client.rs

@@ -15,7 +15,8 @@
 // along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
 
 use client::{Rpc, RpcError};
-use rpc::signer::{ConfirmationRequest, TransactionModification, U256, TransactionCondition};
+use ethereum_types::U256;
+use rpc::signer::{ConfirmationRequest, TransactionModification, TransactionCondition};
 use serde;
 use serde_json::{Value as JsonValue, to_value};
 use std::path::PathBuf;

cli-signer/src/lib.rs

@@ -14,13 +14,15 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
 
+extern crate ethereum_types;
 extern crate futures;
 extern crate rpassword;
 
 extern crate parity_rpc as rpc;
 extern crate parity_rpc_client as client;
 
-use rpc::signer::{U256, ConfirmationRequest};
+use ethereum_types::U256;
+use rpc::signer::ConfirmationRequest;
 use client::signer_client::SignerRpc;
 use std::io::{Write, BufRead, BufReader, stdout, stdin};
 use std::path::PathBuf;

ethcore/private-tx/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Parity Technologies <admin@parity.io>"]
 
 [dependencies]
 common-types = { path = "../types" }
-error-chain = { version = "0.12", default-features = false }
+derive_more = "0.14.0"
 ethabi = "6.0"
 ethabi-contract = "6.0"
 ethabi-derive = "6.0"
@@ -36,7 +36,7 @@ serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 tiny-keccak = "1.4"
-transaction-pool = "1.13.2"
+transaction-pool = "2.0"
 url = "1"
 
 [dev-dependencies]

ethcore/private-tx/src/encryptor.rs

@@ -31,7 +31,7 @@ use crypto;
 use futures::Future;
 use fetch::{Fetch, Client as FetchClient, Method, BodyReader, Request};
 use bytes::{Bytes, ToPretty};
-use error::{Error, ErrorKind};
+use error::Error;
 use url::Url;
 use super::Signer;
 use super::key_server_keys::address_to_key;
@@ -111,11 +111,11 @@ impl SecretStoreEncryptor {
  return Ok(key);
  }
  let contract_address_signature = self.sign_contract_address(contract_address)?;
- let requester = self.config.key_server_account.ok_or_else(|| ErrorKind::KeyServerAccountNotSet)?;
+ let requester = self.config.key_server_account.ok_or_else(|| Error::KeyServerAccountNotSet)?;
 
  // key id in SS is H256 && we have H160 here => expand with assitional zeros
  let contract_address_extended: H256 = contract_address.into();
- let base_url = self.config.base_url.clone().ok_or_else(|| ErrorKind::KeyServerNotSet)?;
+ let base_url = self.config.base_url.clone().ok_or_else(|| Error::KeyServerNotSet)?;
 
  // prepare request url
  let url = format!("{}/{}/{}{}",
@@ -132,24 +132,24 @@ impl SecretStoreEncryptor {
  Method::GET
  };
 
- let url = Url::from_str(&url).map_err(|e| ErrorKind::Encrypt(e.to_string()))?;
+ let url = Url::from_str(&url).map_err(|e| Error::Encrypt(e.to_string()))?;
  let response = self.client.fetch(Request::new(url, method), Default::default()).wait()
- .map_err(|e| ErrorKind::Encrypt(e.to_string()))?;
+ .map_err(|e| Error::Encrypt(e.to_string()))?;
 
  if response.is_not_found() {
- bail!(ErrorKind::EncryptionKeyNotFound(*contract_address));
+ return Err(Error::EncryptionKeyNotFound(*contract_address));
  }
 
  if !response.is_success() {
- bail!(ErrorKind::Encrypt(response.status().canonical_reason().unwrap_or("unknown").into()));
+ return Err(Error::Encrypt(response.status().canonical_reason().unwrap_or("unknown").into()));
  }
 
  // read HTTP response
  let mut result = String::new();
  BodyReader::new(response).read_to_string(&mut result)?;
 
  // response is JSON string (which is, in turn, hex-encoded, encrypted Public)
- let encrypted_bytes: ethjson::bytes::Bytes = result.trim_matches('\"').parse().map_err(|e| ErrorKind::Encrypt(e))?;
+ let encrypted_bytes: ethjson::bytes::Bytes = result.trim_matches('\"').parse().map_err(|e| Error::Encrypt(e))?;
 
  // decrypt Public
  let decrypted_bytes = self.signer.decrypt(requester, &crypto::DEFAULT_MAC, &encrypted_bytes)?;
@@ -189,7 +189,7 @@ impl SecretStoreEncryptor {
  }
 
  fn sign_contract_address(&self, contract_address: &Address) -> Result<Signature, Error> {
- let key_server_account = self.config.key_server_account.ok_or_else(|| ErrorKind::KeyServerAccountNotSet)?;
+ let key_server_account = self.config.key_server_account.ok_or_else(|| Error::KeyServerAccountNotSet)?;
  Ok(self.signer.sign(key_server_account, address_to_key(contract_address))?)
  }
 }
@@ -204,7 +204,7 @@ impl Encryptor for SecretStoreEncryptor {
  // retrieve the key, try to generate it if it doesn't exist yet
  let key = match self.retrieve_key("", false, contract_address) {
  Ok(key) => Ok(key),
- Err(Error(ErrorKind::EncryptionKeyNotFound(_), _)) => {
+ Err(Error::EncryptionKeyNotFound(_)) => {
  trace!(target: "privatetx", "Key for account wasnt found in sstore. Creating. Address: {:?}", contract_address);
  self.retrieve_key(&format!("/{}", self.config.threshold), true, contract_address)
  }
@@ -215,7 +215,7 @@ impl Encryptor for SecretStoreEncryptor {
  let mut cypher = Vec::with_capacity(plain_data.len() + initialisation_vector.len());
  cypher.extend(repeat(0).take(plain_data.len()));
  crypto::aes::encrypt_128_ctr(&key, initialisation_vector, plain_data, &mut cypher)
- .map_err(|e| ErrorKind::Encrypt(e.to_string()))?;
+ .map_err(|e| Error::Encrypt(e.to_string()))?;
  cypher.extend_from_slice(&initialisation_vector);
 
  Ok(cypher)
@@ -230,7 +230,7 @@ impl Encryptor for SecretStoreEncryptor {
  // initialization vector takes INIT_VEC_LEN bytes
  let cypher_len = cypher.len();
  if cypher_len < INIT_VEC_LEN {
- bail!(ErrorKind::Decrypt("Invalid cypher".into()));
+ return Err(Error::Decrypt("Invalid cypher".into()));
  }
 
  // retrieve existing key
@@ -241,7 +241,7 @@ impl Encryptor for SecretStoreEncryptor {
  let mut plain_data = Vec::with_capacity(cypher_len - INIT_VEC_LEN);
  plain_data.extend(repeat(0).take(cypher_len - INIT_VEC_LEN));
  crypto::aes::decrypt_128_ctr(&key, &iv, cypher, &mut plain_data)
- .map_err(|e| ErrorKind::Decrypt(e.to_string()))?;
+ .map_err(|e| Error::Decrypt(e.to_string()))?;
  Ok(plain_data)
  }
 }