Update to parity-scale-codec (#3232)

* WIP: update codec

* WIP

* compiling

* WIP

* rename parity-scale-codec to codec

* WIP

* fix

* remove old comments

* use published crates

* fix expected error msg

* bump version

* fmt and fix

* remove old comment

* fix wrong decoding impl

* implement encode like for structures

* undo removal of old pending changes

* trailingzeroinput

* Apply suggestions from code review

Co-Authored-By: Bastian Köcher <bkchr@users.noreply.github.com>
Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* update codec

* fmt

* version is 1.0.0

* show more error

* fmt

substrate/core/client/db/src/cache/list_entry.rs

@@ -18,7 +18,7 @@
 
 use client::error::Result as ClientResult;
 use sr_primitives::traits::{Block as BlockT, NumberFor};
-use parity_codec::{Encode, Decode};
+use codec::{Encode, Decode};
 
 use crate::cache::{CacheItemT, ComplexBlockId};
 use crate::cache::list_storage::{Storage};

substrate/core/client/db/src/cache/list_storage.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 use kvdb::{KeyValueDB, DBTransaction};
 
 use client::error::{Error as ClientError, Result as ClientResult};
-use parity_codec::{Encode, Decode};
+use codec::{Encode, Decode};
 use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor};
 use crate::utils::{self, db_err, meta_keys};
@@ -151,7 +151,7 @@ impl<Block: BlockT, T: CacheItemT> Storage<Block, T> for DbStorage {
 			.map_err(db_err)
 			.and_then(|entry| match entry {
 				Some(entry) => StorageEntry::<Block, T>::decode(&mut &entry[..])
-					.ok_or_else(|| ClientError::Backend("Failed to decode cache entry".into()))
+					.map_err(|_| ClientError::Backend("Failed to decode cache entry".into()))
 					.map(Some),
 				None => Ok(None),
 			})
@@ -236,9 +236,9 @@ mod meta {
 	pub fn decode<Block: BlockT>(encoded: &[u8]) -> ClientResult<Metadata<Block>> {
 		let input = &mut &*encoded;
 		let finalized: Option<ComplexBlockId<Block>> = Decode::decode(input)
-			.ok_or_else(|| ClientError::from(ClientError::Backend("Error decoding cache meta".into())))?;
+			.map_err(|_| ClientError::from(ClientError::Backend("Error decoding cache meta".into())))?;
 		let unfinalized: Vec<ComplexBlockId<Block>> = Decode::decode(input)
-			.ok_or_else(|| ClientError::from(ClientError::Backend("Error decoding cache meta".into())))?;
+			.map_err(|_| ClientError::from(ClientError::Backend("Error decoding cache meta".into())))?;
 
 		Ok(Metadata { finalized, unfinalized })
 	}

substrate/core/client/db/src/cache/mod.rs

@@ -23,7 +23,7 @@ use kvdb::{KeyValueDB, DBTransaction};
 
 use client::blockchain::Cache as BlockchainCache;
 use client::error::Result as ClientResult;
-use parity_codec::{Encode, Decode};
+use codec::{Encode, Decode};
 use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
 use consensus_common::well_known_cache_keys::Id as CacheKeyId;

substrate/core/client/db/src/lib.rs

@@ -42,7 +42,7 @@ use client::backend::NewBlockState;
 use client::blockchain::HeaderBackend;
 use client::ExecutionStrategies;
 use client::backend::{StorageCollection, ChildStorageCollection};
-use parity_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use hash_db::{Hasher, Prefix};
 use kvdb::{KeyValueDB, DBTransaction};
 use trie::{MemoryDB, PrefixedMemoryDB, prefixed_key};
@@ -338,8 +338,10 @@ impl<Block: BlockT> client::blockchain::Backend<Block> for BlockchainDb<Block> {
 	fn body(&self, id: BlockId<Block>) -> Result<Option<Vec<Block::Extrinsic>>, client::error::Error> {
 		match read_db(&*self.db, columns::KEY_LOOKUP, columns::BODY, id)? {
 			Some(body) => match Decode::decode(&mut &body[..]) {
-				Some(body) => Ok(Some(body)),
-				None => return Err(client::error::Error::Backend("Error decoding body".into())),
+				Ok(body) => Ok(Some(body)),
+				Err(err) => return Err(client::error::Error::Backend(
+					format!("Error decoding body: {}", err)
+				)),
 			}
 			None => Ok(None),
 		}
@@ -348,8 +350,10 @@ impl<Block: BlockT> client::blockchain::Backend<Block> for BlockchainDb<Block> {
 	fn justification(&self, id: BlockId<Block>) -> Result<Option<Justification>, client::error::Error> {
 		match read_db(&*self.db, columns::KEY_LOOKUP, columns::JUSTIFICATION, id)? {
 			Some(justification) => match Decode::decode(&mut &justification[..]) {
-				Some(justification) => Ok(Some(justification)),
-				None => return Err(client::error::Error::Backend("Error decoding justification".into())),
+				Ok(justification) => Ok(Some(justification)),
+				Err(err) => return Err(client::error::Error::Backend(
+					format!("Error decoding justification: {}", err)
+				)),
 			}
 			None => Ok(None),
 		}
@@ -838,7 +842,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 				let changes_trie_config = self
 					.state_at(BlockId::Hash(block))?
 					.storage(well_known_keys::CHANGES_TRIE_CONFIG)?
-					.and_then(|v| Decode::decode(&mut &*v));
+					.and_then(|v| Decode::decode(&mut &*v).ok());
 				*cached_changes_trie_config = Some(changes_trie_config.clone());
 				Ok(changes_trie_config)
 			},

substrate/core/client/db/src/light.rs

@@ -29,7 +29,7 @@ use client::cht;
 use client::leaves::{LeafSet, FinalizationDisplaced};
 use client::error::{Error as ClientError, Result as ClientResult};
 use client::light::blockchain::Storage as LightBlockchainStorage;
-use parity_codec::{Decode, Encode};
+use codec::{Decode, Encode};
 use primitives::Blake2Hasher;
 use sr_primitives::generic::{DigestItem, BlockId};
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, Zero, One, NumberFor};
@@ -360,7 +360,7 @@ impl<Block: BlockT> LightStorage<Block> {
 		let cht_start = cht::start_number(cht_size, cht_number);
 		self.db.get(columns::CHT, &cht_key(cht_type, cht_start)?).map_err(db_err)?
 			.ok_or_else(no_cht_for_block)
-			.and_then(|hash| Block::Hash::decode(&mut &*hash).ok_or_else(no_cht_for_block))
+			.and_then(|hash| Block::Hash::decode(&mut &*hash).map_err(|_| no_cht_for_block()))
 	}
 }
 
@@ -887,7 +887,8 @@ pub(crate) mod tests {
 		}
 
 		fn get_authorities(cache: &dyn BlockchainCache<Block>, at: BlockId<Block>) -> Option<Vec<AuthorityId>> {
-			cache.get_at(&well_known_cache_keys::AUTHORITIES, &at).and_then(|val| Decode::decode(&mut &val[..]))
+			cache.get_at(&well_known_cache_keys::AUTHORITIES, &at)
+				.and_then(|val| Decode::decode(&mut &val[..]).ok())
 		}
 
 		let auth1 = || AuthorityId::from_raw([1u8; 32]);

substrate/core/client/db/src/utils.rs

@@ -27,7 +27,7 @@ use kvdb_rocksdb::{Database, DatabaseConfig};
 use log::debug;
 
 use client;
-use parity_codec::Decode;
+use codec::Decode;
 use trie::DBValue;
 use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{
@@ -260,8 +260,8 @@ pub fn read_header<Block: BlockT>(
 ) -> client::error::Result<Option<Block::Header>> {
 	match read_db(db, col_index, col, id)? {
 		Some(header) => match Block::Header::decode(&mut &header[..]) {
-			Some(header) => Ok(Some(header)),
-			None => return Err(
+			Ok(header) => Ok(Some(header)),
+			Err(_) => return Err(
 				client::error::Error::Backend("Error decoding header".into())
 			),
 		}
@@ -290,8 +290,10 @@ pub fn read_meta<Block>(db: &dyn KeyValueDB, col_meta: Option<u32>, col_header:
 {
 	let genesis_hash: Block::Hash = match db.get(col_meta, meta_keys::GENESIS_HASH).map_err(db_err)? {
 		Some(h) => match Decode::decode(&mut &h[..]) {
-			Some(h) => h,
-			None => return Err(client::error::Error::Backend("Error decoding genesis hash".into())),
+			Ok(h) => h,
+			Err(err) => return Err(client::error::Error::Backend(
+				format!("Error decoding genesis hash: {}", err)
+			)),
 		},
 		None => return Ok(Meta {
 			best_hash: Default::default(),
@@ -305,7 +307,7 @@ pub fn read_meta<Block>(db: &dyn KeyValueDB, col_meta: Option<u32>, col_header:
 	let load_meta_block = |desc, key| -> Result<_, client::error::Error> {
 		if let Some(Some(header)) = db.get(col_meta, key).and_then(|id|
 			match id {
-				Some(id) => db.get(col_header, &id).map(|h| h.map(|b| Block::Header::decode(&mut &b[..]))),
+				Some(id) => db.get(col_header, &id).map(|h| h.map(|b| Block::Header::decode(&mut &b[..]).ok())),
 				None => Ok(None),
 			}).map_err(db_err)?
 		{