Merge branch 'master' into genesis-code-spec

# Conflicts:
#	srml/support/procedural/src/storage/genesis_config/genesis_config_def.rs

.gitlab-ci.yml

@@ -338,6 +338,22 @@ check_warnings:
       fi
   allow_failure:                   true
 
+check_polkadot:
+  stage:                           build
+  <<:                              *docker-env
+  allow_failure:                   true
+  dependencies:
+    - test-linux-stable
+  script:
+    - git clone --depth 1 https://github.com/paritytech/polkadot.git
+    - COMMIT_HASH=$(git rev-parse HEAD)
+    - cd polkadot
+    - git grep -l "polkadot-master" | grep toml | xargs sed -i "s/branch.*=.*\"polkadot-master\"/rev = \"$COMMIT_HASH\"/"
+    - cargo update -p sr-io --precise $COMMIT_HASH
+    - time cargo check
+    - cd ..
+    - sccache -s
+
 #### stage:                        publish
 
 .publish-docker-release:           &publish-docker-release

core/authority-discovery/Cargo.toml

@@ -15,7 +15,7 @@ client = { package = "substrate-client", path = "../../core/client" }
 codec = { package = "parity-scale-codec", default-features = false, version = "1.0.3" }
 derive_more = "0.15.0"
 futures-preview = "0.3.0-alpha.19"
-libp2p = { version = "0.12.0", default-features = false, features = ["secp256k1", "libp2p-websocket"] }
+libp2p = { version = "0.13.0", default-features = false, features = ["secp256k1", "libp2p-websocket"] }
 log = "0.4.8"
 network = { package = "substrate-network", path = "../../core/network" }
 primitives = { package = "substrate-primitives", path = "../primitives" }

core/chain-spec/derive/Cargo.toml

@@ -9,8 +9,8 @@ proc-macro = true
 
 [dependencies]
 proc-macro-crate = "0.1.4"
-proc-macro2 = "1.0.4"
+proc-macro2 = "1.0.6"
 quote = "1.0.2"
-syn = "1.0.5"
+syn = "1.0.7"
 
 [dev-dependencies]

core/client/db/src/lib.rs

@@ -894,12 +894,6 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 		inmem
 	}
 
-	/// Returns total numbet of blocks (headers) in the block DB.
-	#[cfg(feature = "test-helpers")]
-	pub fn blocks_count(&self) -> u64 {
-		self.blockchain.db.iter(columns::HEADER).count() as u64
-	}
-
 	/// Read (from storage or cache) changes trie config.
 	///
 	/// Currently changes tries configuration is set up once (at genesis) and could not
@@ -1121,7 +1115,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 			);
 
 			transaction.put(columns::HEADER, &lookup_key, &pending_block.header.encode());
-			if let Some(body) = &pending_block.body {
+			if let Some(body) = pending_block.body {
 				transaction.put(columns::BODY, &lookup_key, &body.encode());
 			}
 			if let Some(justification) = pending_block.justification {
@@ -1133,26 +1127,21 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 				transaction.put(columns::META, meta_keys::GENESIS_HASH, hash.as_ref());
 			}
 
-			let finalized = if pending_block.body.is_some() {
-				let mut changeset: state_db::ChangeSet<Vec<u8>> = state_db::ChangeSet::default();
-				for (key, (val, rc)) in operation.db_updates.drain() {
-					if rc > 0 {
-						changeset.inserted.push((key, val.to_vec()));
-					} else if rc < 0 {
-						changeset.deleted.push(key);
-					}
+			let mut changeset: state_db::ChangeSet<Vec<u8>> = state_db::ChangeSet::default();
+			for (key, (val, rc)) in operation.db_updates.drain() {
+				if rc > 0 {
+					changeset.inserted.push((key, val.to_vec()));
+				} else if rc < 0 {
+					changeset.deleted.push(key);
 				}
-				let number_u64 = number.saturated_into::<u64>();
-				let commit = self.storage.state_db.insert_block(&hash, number_u64, &pending_block.header.parent_hash(), changeset)
-					.map_err(|e: state_db::Error<io::Error>| client::error::Error::from(format!("State database error: {:?}", e)))?;
-				apply_state_commit(&mut transaction, commit);
-
-				// Check if need to finalize. Genesis is always finalized instantly.
-				let finalized = number_u64 == 0 || pending_block.leaf_state.is_final();
-				finalized
-			} else {
-				false
-			};
+			}
+			let number_u64 = number.saturated_into::<u64>();
+			let commit = self.storage.state_db.insert_block(&hash, number_u64, &pending_block.header.parent_hash(), changeset)
+				.map_err(|e: state_db::Error<io::Error>| client::error::Error::from(format!("State database error: {:?}", e)))?;
+			apply_state_commit(&mut transaction, commit);
+
+			// Check if need to finalize. Genesis is always finalized instantly.
+			let finalized = number_u64 == 0 || pending_block.leaf_state.is_final();
 
 			let header = &pending_block.header;
 			let is_best = pending_block.leaf_state.is_best();
@@ -1592,7 +1581,7 @@ mod tests {
 		};
 		let mut op = backend.begin_operation().unwrap();
 		backend.begin_state_operation(&mut op, block_id).unwrap();
-		op.set_block_data(header, Some(Vec::new()), None, NewBlockState::Best).unwrap();
+		op.set_block_data(header, None, None, NewBlockState::Best).unwrap();
 		op.update_changes_trie((changes_trie_update, ChangesTrieCacheAction::Clear)).unwrap();
 		backend.commit_operation(op).unwrap();
 

core/client/src/backend.rs

@@ -85,16 +85,21 @@ impl NewBlockState {
 	}
 }
 
-/// Block insertion operation. Keeps hold if the inserted block state and data.
+/// Block insertion operation.
+///
+/// Keeps hold if the inserted block state and data.
 pub trait BlockImportOperation<Block, H> where
 	Block: BlockT,
 	H: Hasher<Out=Block::Hash>,
 {
 	/// Associated state backend type.
 	type State: StateBackend<H>;
 
-	/// Returns pending state. Returns None for backends with locally-unavailable state data.
+	/// Returns pending state.
+	///
+	/// Returns None for backends with locally-unavailable state data.
 	fn state(&self) -> error::Result<Option<&Self::State>>;
+
 	/// Append block data to the transaction.
 	fn set_block_data(
 		&mut self,
@@ -106,21 +111,29 @@ pub trait BlockImportOperation<Block, H> where
 
 	/// Update cached data.
 	fn update_cache(&mut self, cache: HashMap<well_known_cache_keys::Id, Vec<u8>>);
+
 	/// Inject storage data into the database.
 	fn update_db_storage(&mut self, update: <Self::State as StateBackend<H>>::Transaction) -> error::Result<()>;
+
 	/// Inject storage data into the database replacing any existing data.
 	fn reset_storage(&mut self, top: StorageOverlay, children: ChildrenStorageOverlay) -> error::Result<H::Out>;
+
 	/// Set storage changes.
 	fn update_storage(
 		&mut self,
 		update: StorageCollection,
 		child_update: ChildStorageCollection,
 	) -> error::Result<()>;
+
 	/// Inject changes trie data into the database.
 	fn update_changes_trie(&mut self, update: ChangesTrieTransaction<H, NumberFor<Block>>) -> error::Result<()>;
-	/// Insert auxiliary keys. Values are `None` if should be deleted.
+
+	/// Insert auxiliary keys.
+	///
+	/// Values are `None` if should be deleted.
 	fn insert_aux<I>(&mut self, ops: I) -> error::Result<()>
 		where I: IntoIterator<Item=(Vec<u8>, Option<Vec<u8>>)>;
+
 	/// Mark a block as finalized.
 	fn mark_finalized(&mut self, id: BlockId<Block>, justification: Option<Justification>) -> error::Result<()>;
 	/// Mark a block as new head. If both block import and set head are specified, set head overrides block import's best block rule.
@@ -129,8 +142,9 @@ pub trait BlockImportOperation<Block, H> where
 
 /// Finalize Facilities
 pub trait Finalizer<Block: BlockT, H: Hasher<Out=Block::Hash>, B: Backend<Block, H>> {
-	/// Mark all blocks up to given as finalized in operation. If a
-	/// justification is provided it is stored with the given finalized
+	/// Mark all blocks up to given as finalized in operation.
+	///
+	/// If `justification` is provided it is stored with the given finalized
 	/// block (any other finalized blocks are left unjustified).
 	///
 	/// If the block being finalized is on a different fork from the current
@@ -146,7 +160,9 @@ pub trait Finalizer<Block: BlockT, H: Hasher<Out=Block::Hash>, B: Backend<Block,
 	) -> error::Result<()>;
 
 
-	/// Finalize a block. This will implicitly finalize all blocks up to it and
+	/// Finalize a block.
+	///
+	/// This will implicitly finalize all blocks up to it and
 	/// fire finality notifications.
 	///
 	/// If the block being finalized is on a different fork from the current
@@ -168,19 +184,24 @@ pub trait Finalizer<Block: BlockT, H: Hasher<Out=Block::Hash>, B: Backend<Block,
 
 /// Provides access to an auxiliary database.
 pub trait AuxStore {
-	/// Insert auxiliary data into key-value store. Deletions occur after insertions.
+	/// Insert auxiliary data into key-value store.
+	///
+	/// Deletions occur after insertions.
 	fn insert_aux<
 		'a,
 		'b: 'a,
 		'c: 'a,
 		I: IntoIterator<Item=&'a(&'c [u8], &'c [u8])>,
 		D: IntoIterator<Item=&'a &'b [u8]>,
 	>(&self, insert: I, delete: D) -> error::Result<()>;
+
 	/// Query auxiliary data from key-value store.
 	fn get_aux(&self, key: &[u8]) -> error::Result<Option<Vec<u8>>>;
 }
 
-/// Client backend. Manages the data layer.
+/// Client backend.
+///
+/// Manages the data layer.
 ///
 /// Note on state pruning: while an object from `state_at` is alive, the state
 /// should not be pruned. The backend should internally reference-count
@@ -204,35 +225,49 @@ pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	type OffchainStorage: OffchainStorage;
 
 	/// Begin a new block insertion transaction with given parent block id.
+	///
 	/// When constructing the genesis, this is called with all-zero hash.
 	fn begin_operation(&self) -> error::Result<Self::BlockImportOperation>;
+
 	/// Note an operation to contain state transition.
 	fn begin_state_operation(&self, operation: &mut Self::BlockImportOperation, block: BlockId<Block>) -> error::Result<()>;
+
 	/// Commit block insertion.
 	fn commit_operation(&self, transaction: Self::BlockImportOperation) -> error::Result<()>;
-	/// Finalize block with given Id. This should only be called if the parent of the given
-	/// block has been finalized.
+
+	/// Finalize block with given Id.
+	///
+	/// This should only be called if the parent of the given block has been finalized.
 	fn finalize_block(&self, block: BlockId<Block>, justification: Option<Justification>) -> error::Result<()>;
+
 	/// Returns reference to blockchain backend.
 	fn blockchain(&self) -> &Self::Blockchain;
+
 	/// Returns the used state cache, if existent.
 	fn used_state_cache_size(&self) -> Option<usize>;
+
 	/// Returns reference to changes trie storage.
 	fn changes_trie_storage(&self) -> Option<&Self::ChangesTrieStorage>;
+
 	/// Returns a handle to offchain storage.
 	fn offchain_storage(&self) -> Option<Self::OffchainStorage>;
+
 	/// Returns true if state for given block is available.
 	fn have_state_at(&self, hash: &Block::Hash, _number: NumberFor<Block>) -> bool {
 		self.state_at(BlockId::Hash(hash.clone())).is_ok()
 	}
+
 	/// Returns state backend with post-state of given block.
 	fn state_at(&self, block: BlockId<Block>) -> error::Result<Self::State>;
+
 	/// Destroy state and save any useful data, such as cache.
 	fn destroy_state(&self, _state: Self::State) -> error::Result<()> {
 		Ok(())
 	}
-	/// Attempts to revert the chain by `n` blocks. Returns the number of blocks that were
-	/// successfully reverted.
+
+	/// Attempts to revert the chain by `n` blocks.
+	///
+	/// Returns the number of blocks that were successfully reverted.
 	fn revert(&self, n: NumberFor<Block>) -> error::Result<NumberFor<Block>>;
 
 	/// Insert auxiliary data into key-value store.
@@ -252,6 +287,7 @@ pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	}
 
 	/// Gain access to the import lock around this backend.
+	///
 	/// _Note_ Backend isn't expected to acquire the lock by itself ever. Rather
 	/// the using components should acquire and hold the lock whenever they do
 	/// something that the import of a block would interfere with, e.g. importing
@@ -306,7 +342,10 @@ where
 {
 	/// Returns true if the state for given block is available locally.
 	fn is_local_state_available(&self, block: &BlockId<Block>) -> bool;
-	/// Returns reference to blockchain backend that either resolves blockchain data
+
+	/// Returns reference to blockchain backend.
+	///
+	/// Returned backend either resolves blockchain data
 	/// locally, or prepares request to fetch that data from remote node.
 	fn remote_blockchain(&self) -> Arc<dyn RemoteBlockchain<Block>>;
 }