Merge branch 'master' of https://github.com/paritytech/parity into wa…

…rp_sync_on_light_client

* 'master' of https://github.com/paritytech/parity:
  Include node identity in the P2P advertised client version. (openethereum#8830)
  Allow disabling local-by-default for transactions with new config entry (openethereum#8882)
  Allow Poll Lifetime to be configured via CLI (openethereum#8885)
  cleanup nibbleslice (openethereum#8915)
  Hardware-wallets `Clean up things I missed in the latest PR` (openethereum#8890)
  Remove debian/.deb and centos/.rpm packaging scripts (openethereum#8887)
  Remove a weird emoji in new_social docs (openethereum#8913)
  Minor fix in chain supplier and light provider (openethereum#8906)

.gitlab-ci.yml

@@ -7,13 +7,12 @@ variables:
  RUSTFLAGS: ""
  CARGOFLAGS: ""
  CI_SERVER_NAME: "GitLab CI"
- LIBSSL: "libssl1.0.0 (>=1.0.0)"
 cache:
  key: "$CI_BUILD_STAGE-$CI_BUILD_REF_NAME"
  paths:
  - target/
  untracked: true
-linux-ubuntu:
+linux-amd64:
  stage: build
  image: parity/rust:gitlab-ci
  only:
@@ -24,46 +23,13 @@ linux-ubuntu:
  script:
  - rustup default stable
  # ARGUMENTS: 1. BUILD_PLATFORM (target for binaries) 2. PLATFORM (target for cargo) 3. ARC (architecture) 4. & 5. CC & CXX flags 6. binary identifier
- - scripts/gitlab-build.sh x86_64-unknown-linux-gnu x86_64-unknown-linux-gnu amd64 gcc g++ ubuntu
+ - scripts/gitlab-build.sh x86_64-unknown-linux-gnu x86_64-unknown-linux-gnu amd64 gcc g++ linux
  tags:
  - rust-stable
  artifacts:
  paths:
  - parity.zip
  name: "stable-x86_64-unknown-linux-gnu_parity"
-linux-debian:
- stage: build
- image: parity/rust-debian:gitlab-ci
- only:
- - beta
- - tags
- - stable
- - triggers
- script:
- - export LIBSSL="libssl1.1 (>=1.1.0)"
- - scripts/gitlab-build.sh x86_64-unknown-debian-gnu x86_64-unknown-linux-gnu amd64 gcc g++ debian
- tags:
- - rust-debian
- artifacts:
- paths:
- - parity.zip
- name: "stable-x86_64-unknown-debian-gnu_parity"
-linux-centos:
- stage: build
- image: parity/rust-centos:gitlab-ci
- only:
- - beta
- - tags
- - stable
- - triggers
- script:
- - scripts/gitlab-build.sh x86_64-unknown-centos-gnu x86_64-unknown-linux-gnu x86_64 gcc g++ centos
- tags:
- - rust-centos
- artifacts:
- paths:
- - parity.zip
- name: "x86_64-unknown-centos-gnu_parity"
 linux-i686:
  stage: build
  image: parity/rust-i686:gitlab-ci
@@ -73,7 +39,7 @@ linux-i686:
  - stable
  - triggers
  script:
- - scripts/gitlab-build.sh i686-unknown-linux-gnu i686-unknown-linux-gnu i386 gcc g++ ubuntu
+ - scripts/gitlab-build.sh i686-unknown-linux-gnu i686-unknown-linux-gnu i386 gcc g++ linux
  tags:
  - rust-i686
  artifacts:
@@ -90,15 +56,15 @@ linux-armv7:
  - stable
  - triggers
  script:
- - scripts/gitlab-build.sh armv7-unknown-linux-gnueabihf armv7-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ ubuntu
+ - scripts/gitlab-build.sh armv7-unknown-linux-gnueabihf armv7-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ linux
  tags:
  - rust-arm
  artifacts:
  paths:
  - parity.zip
  name: "armv7_unknown_linux_gnueabihf_parity"
  allow_failure: true
-linux-arm:
+linux-armhf:
  stage: build
  image: parity/rust-arm:gitlab-ci
  only:
@@ -107,7 +73,7 @@ linux-arm:
  - stable
  - triggers
  script:
- - scripts/gitlab-build.sh arm-unknown-linux-gnueabihf arm-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ ubuntu
+ - scripts/gitlab-build.sh arm-unknown-linux-gnueabihf arm-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ linux
  tags:
  - rust-arm
  artifacts:
@@ -124,7 +90,7 @@ linux-aarch64:
  - stable
  - triggers
  script:
- - scripts/gitlab-build.sh aarch64-unknown-linux-gnu aarch64-unknown-linux-gnu arm64 aarch64-linux-gnu-gcc aarch64-linux-gnu-g++ ubuntu
+ - scripts/gitlab-build.sh aarch64-unknown-linux-gnu aarch64-unknown-linux-gnu arm64 aarch64-linux-gnu-gcc aarch64-linux-gnu-g++ linux
  tags:
  - rust-arm
  artifacts:

ethcore/light/src/provider.rs

@@ -54,6 +54,7 @@ pub trait Provider: Send + Sync {
  /// results within must adhere to the `skip` and `reverse` parameters.
  fn block_headers(&self, req: request::CompleteHeadersRequest) -> Option<request::HeadersResponse> {
  use request::HashOrNumber;
+ const MAX_HEADERS_TO_SEND: u64 = 512;
 
  if req.max == 0 { return None }
 
@@ -82,10 +83,12 @@ pub trait Provider: Send + Sync {
  }
  };
 
- let headers: Vec<_> = (0u64..req.max as u64)
- .map(|x: u64| x.saturating_mul(req.skip + 1))
+ let max = ::std::cmp::min(MAX_HEADERS_TO_SEND, req.max);
+
+ let headers: Vec<_> = (0u64..max)
+ .map(|x: u64| x.saturating_mul(req.skip.saturating_add(1)))
  .take_while(|x| if req.reverse { x < &start_num } else { best_num.saturating_sub(start_num) >= *x })
- .map(|x| if req.reverse { start_num - x } else { start_num + x })
+ .map(|x| if req.reverse { start_num.saturating_sub(x) } else { start_num.saturating_add(x) })
  .map(|x| self.block_header(BlockId::Number(x)))
  .take_while(|x| x.is_some())
  .flat_map(|x| x)

ethcore/src/ethereum/mod.rs

@@ -81,7 +81,7 @@ pub fn new_easthub<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
  load(params.into(), include_bytes!("../../res/ethereum/easthub.json"))
 }
 
-/// Create a new Ethereum Social mainnet chain spec ¯\_(ツ)_/¯ .
+/// Create a new Ethereum Social mainnet chain spec.
 pub fn new_social<'a, T: Into<SpecParams<'a>>>(params: T) -> Spec {
  load(params.into(), include_bytes!("../../res/ethereum/social.json"))
 }

ethcore/src/miner/miner.rs

@@ -125,6 +125,8 @@ pub struct MinerOptions {
  pub tx_queue_strategy: PrioritizationStrategy,
  /// Simple senders penalization.
  pub tx_queue_penalization: Penalization,
+ /// Do we want to mark transactions recieved locally (e.g. RPC) as local if we don't have the sending account?
+ pub tx_queue_no_unfamiliar_locals: bool,
  /// Do we refuse to accept service transactions even if sender is certified.
  pub refuse_service_transactions: bool,
  /// Transaction pool limits.
@@ -148,6 +150,7 @@ impl Default for MinerOptions {
  infinite_pending_block: false,
  tx_queue_strategy: PrioritizationStrategy::GasPriceOnly,
  tx_queue_penalization: Penalization::Disabled,
+ tx_queue_no_unfamiliar_locals: false,
  refuse_service_transactions: false,
  pool_limits: pool::Options {
  max_count: 8_192,
@@ -794,8 +797,9 @@ impl miner::MinerService for Miner {
  fn import_own_transaction<C: miner::BlockChainClient>(
  &self,
  chain: &C,
- pending: PendingTransaction,
+ pending: PendingTransaction
  ) -> Result<(), transaction::Error> {
+ // note: you may want to use `import_claimed_local_transaction` instead of this one.
 
  trace!(target: "own_tx", "Importing transaction: {:?}", pending);
 
@@ -816,6 +820,28 @@ impl miner::MinerService for Miner {
  imported
  }
 
+ fn import_claimed_local_transaction<C: miner::BlockChainClient>(
+ &self,
+ chain: &C,
+ pending: PendingTransaction,
+ trusted: bool
+ ) -> Result<(), transaction::Error> {
+ // treat the tx as local if the option is enabled, or if we have the account
+ let sender = pending.sender();
+ let treat_as_local = trusted
+ || !self.options.tx_queue_no_unfamiliar_locals
+ || self.accounts.as_ref().map(|accts| accts.has_account(sender)).unwrap_or(false);
+
+ if treat_as_local {
+ self.import_own_transaction(chain, pending)
+ } else {
+ // We want to replicate behaviour for external transactions if we're not going to treat
+ // this as local. This is important with regards to sealing blocks
+ self.import_external_transactions(chain, vec![pending.transaction.into()])
+ .pop().expect("one result per tx, as in `import_own_transaction`")
+ }
+ }
+
  fn local_transactions(&self) -> BTreeMap<H256, pool::local_transactions::Status> {
  self.transaction_queue.local_transactions()
  }
@@ -1161,6 +1187,7 @@ mod tests {
  infinite_pending_block: false,
  tx_queue_penalization: Penalization::Disabled,
  tx_queue_strategy: PrioritizationStrategy::GasPriceOnly,
+ tx_queue_no_unfamiliar_locals: false,
  refuse_service_transactions: false,
  pool_limits: Default::default(),
  pool_verification_options: pool::verifier::Options {
@@ -1175,8 +1202,10 @@ mod tests {
  )
  }
 
+ const TEST_CHAIN_ID: u64 = 2;
+
  fn transaction() -> SignedTransaction {
- transaction_with_chain_id(2)
+ transaction_with_chain_id(TEST_CHAIN_ID)
  }
 
  fn transaction_with_chain_id(chain_id: u64) -> SignedTransaction {
@@ -1250,6 +1279,53 @@ mod tests {
  assert_eq!(miner.ready_transactions(&client, 10, PendingOrdering::Priority).len(), 1);
  }
 
+ #[test]
+ fn should_treat_unfamiliar_locals_selectively() {
+ // given
+ let keypair = Random.generate().unwrap();
+ let client = TestBlockChainClient::default();
+ let account_provider = AccountProvider::transient_provider();
+ account_provider.insert_account(keypair.secret().clone(), "").expect("can add accounts to the provider we just created");
+
+ let miner = Miner::new(
+ MinerOptions {
+ tx_queue_no_unfamiliar_locals: true,
+ ..miner().options
+ },
+ GasPricer::new_fixed(0u64.into()),
+ &Spec::new_test(),
+ Some(Arc::new(account_provider)),
+ );
+ let transaction = transaction();
+ let best_block = 0;
+ // when
+ // This transaction should not be marked as local because our account_provider doesn't have the sender
+ let res = miner.import_claimed_local_transaction(&client, PendingTransaction::new(transaction.clone(), None), false);
+
+ // then
+ // Check the same conditions as `should_import_external_transaction` first. Behaviour should be identical.
+ // That is: it's treated as though we added it through `import_external_transactions`
+ assert_eq!(res.unwrap(), ());
+ assert_eq!(miner.pending_transactions(best_block), None);
+ assert_eq!(miner.pending_receipts(best_block), None);
+ assert_eq!(miner.ready_transactions(&client, 10, PendingOrdering::Priority).len(), 0);
+ assert!(miner.prepare_pending_block(&client));
+ assert_eq!(miner.ready_transactions(&client, 10, PendingOrdering::Priority).len(), 1);
+
+ // when - 2nd part: create a local transaction from account_provider.
+ // Borrow the transaction used before & sign with our generated keypair.
+ let local_transaction = transaction.deconstruct().0.as_unsigned().clone().sign(keypair.secret(), Some(TEST_CHAIN_ID));
+ let res2 = miner.import_claimed_local_transaction(&client, PendingTransaction::new(local_transaction, None), false);
+
+ // then - 2nd part: we add on the results from the last pending block.
+ // This is borrowed from `should_make_pending_block_when_importing_own_transaction` and slightly modified.
+ assert_eq!(res2.unwrap(), ());
+ assert_eq!(miner.pending_transactions(best_block).unwrap().len(), 2);
+ assert_eq!(miner.pending_receipts(best_block).unwrap().len(), 2);
+ assert_eq!(miner.ready_transactions(&client, 10, PendingOrdering::Priority).len(), 2);
+ assert!(!miner.prepare_pending_block(&client));
+ }
+
  #[test]
  fn should_not_seal_unless_enabled() {
  let miner = miner();

ethcore/src/miner/mod.rs

@@ -138,6 +138,12 @@ pub trait MinerService : Send + Sync {
  -> Result<(), transaction::Error>
  where C: BlockChainClient;
 
+ /// Imports transactions from potentially external sources, with behaviour determined
+ /// by the config flag `tx_queue_allow_unfamiliar_locals`
+ fn import_claimed_local_transaction<C>(&self, chain: &C, transaction: PendingTransaction, trusted: bool)
+ -> Result<(), transaction::Error>
+ where C: BlockChainClient;
+
  /// Removes transaction from the pool.
  ///
  /// Attempts to "cancel" a transaction. If it was not propagated yet (or not accepted by other peers)

ethcore/sync/src/chain/supplier.rs

@@ -133,7 +133,7 @@ impl SyncSupplier {
  let max_count = cmp::min(MAX_HEADERS_TO_SEND, max_headers);
  let mut count = 0;
  let mut data = Bytes::new();
- let inc = (skip + 1) as BlockNumber;
+ let inc = skip.saturating_add(1) as BlockNumber;
  let overlay = io.chain_overlay().read();
 
  // We are checking the `overlay` as well since it's where the ForkBlock
@@ -155,9 +155,9 @@ impl SyncSupplier {
  if number <= inc || number == 0 {
  break;
  }
- number -= inc;
+ number = number.saturating_sub(inc);
  } else {
- number += inc;
+ number = number.saturating_add(inc);
  }
  }
  let mut rlp = RlpStream::new_list(count as usize);