diff --git a/polkadot/api/src/full.rs b/polkadot/api/src/full.rs index 7f340b53b6..7a5aeb31e7 100644 --- a/polkadot/api/src/full.rs +++ b/polkadot/api/src/full.rs @@ -93,7 +93,7 @@ impl> PolkadotApi for Client Result { use substrate_executor::error::ErrorKind as ExecErrorKind; - use codec::Slicable; + use codec::{Decode, Encode}; use runtime::Block as RuntimeBlock; let encoded = block.encode(); @@ -142,13 +142,13 @@ impl> PolkadotApi for Client) -> Result> { - use codec::Slicable; + use codec::{Encode, Decode}; with_runtime!(self, at, || { let extrinsics = ::runtime::inherent_extrinsics(timestamp, new_heads); extrinsics.into_iter() .map(|x| x.encode()) // get encoded representation - .map(|x| Slicable::decode(&mut &x[..])) // get byte-vec equivalent to extrinsic + .map(|x| Decode::decode(&mut &x[..])) // get byte-vec equivalent to extrinsic .map(|x| x.expect("UncheckedExtrinsic has encoded representation equivalent to Vec; qed")) .collect() }) diff --git a/polkadot/api/src/light.rs b/polkadot/api/src/light.rs index c0eb691e32..7e2015c0b7 100644 --- a/polkadot/api/src/light.rs +++ b/polkadot/api/src/light.rs @@ -19,7 +19,7 @@ use std::sync::Arc; use client::backend::{Backend, RemoteBackend}; use client::{Client, CallExecutor}; -use codec::Slicable; +use codec::Decode; use primitives::{AccountId, Block, BlockId, Hash, Index, SessionKey, Timestamp, UncheckedExtrinsic}; use runtime::Address; use primitives::parachain::{CandidateReceipt, DutyRoster, Id as ParaId}; diff --git a/polkadot/cli/src/lib.rs b/polkadot/cli/src/lib.rs index e0d9443d62..a4b1900d22 100644 --- a/polkadot/cli/src/lib.rs +++ b/polkadot/cli/src/lib.rs @@ -79,7 +79,7 @@ use std::net::SocketAddr; use std::path::{Path, PathBuf}; use substrate_telemetry::{init_telemetry, TelemetryConfig}; use polkadot_primitives::BlockId; -use codec::Slicable; +use codec::{Decode, Encode}; use client::BlockOrigin; use runtime_primitives::generic::SignedBlock; @@ -407,7 +407,7 @@ fn import_blocks(matches: &clap::ArgMatches, exit: E) -> error::Result<()> }; info!("Importing blocks"); - let count: u32 = Slicable::decode(&mut file).ok_or("Error reading file")?; + let count: u32 = Decode::decode(&mut file).ok_or("Error reading file")?; let mut block = 0; for _ in 0 .. count { if exit_recv.try_recv().is_ok() { diff --git a/polkadot/consensus/src/evaluation.rs b/polkadot/consensus/src/evaluation.rs index c7c4fe2c25..d843e79de4 100644 --- a/polkadot/consensus/src/evaluation.rs +++ b/polkadot/consensus/src/evaluation.rs @@ -18,7 +18,7 @@ use super::MAX_TRANSACTIONS_SIZE; -use codec::Slicable; +use codec::{Decode, Encode}; use polkadot_runtime::{Block as PolkadotGenericBlock, CheckedBlock}; use polkadot_primitives::{Block, Hash, BlockNumber, Timestamp}; use polkadot_primitives::parachain::Id as ParaId; @@ -78,13 +78,13 @@ pub fn evaluate_initial( ) -> Result { const MAX_TIMESTAMP_DRIFT: Timestamp = 60; - let encoded = Slicable::encode(proposal); + let encoded = Encode::encode(proposal); let proposal = PolkadotGenericBlock::decode(&mut &encoded[..]) .and_then(|b| CheckedBlock::new(b).ok()) .ok_or_else(|| ErrorKind::ProposalNotForPolkadot)?; let transactions_size = proposal.extrinsics.iter().fold(0, |a, tx| { - a + Slicable::encode(tx).len() + a + Encode::encode(tx).len() }); if transactions_size > MAX_TRANSACTIONS_SIZE { diff --git a/polkadot/consensus/src/lib.rs b/polkadot/consensus/src/lib.rs index 7edc78ea11..4ad6ba9544 100644 --- a/polkadot/consensus/src/lib.rs +++ b/polkadot/consensus/src/lib.rs @@ -65,7 +65,7 @@ use std::collections::{HashMap, HashSet}; use std::sync::Arc; use std::time::{Duration, Instant}; -use codec::Slicable; +use codec::{Decode, Encode}; use polkadot_api::PolkadotApi; use polkadot_primitives::{Hash, Block, BlockId, BlockNumber, Header, Timestamp, SessionKey}; use polkadot_primitives::parachain::{Id as ParaId, Chain, DutyRoster, BlockData, Extrinsic as ParachainExtrinsic, CandidateReceipt, CandidateSignature}; @@ -710,7 +710,7 @@ impl CreateProposal where C: PolkadotApi { .join(", ") ); - let substrate_block = Slicable::decode(&mut polkadot_block.encode().as_slice()) + let substrate_block = Decode::decode(&mut polkadot_block.encode().as_slice()) .expect("polkadot blocks defined to serialize to substrate blocks correctly; qed"); // TODO: full re-evaluation diff --git a/polkadot/network/src/lib.rs b/polkadot/network/src/lib.rs index fc143e92af..fe320eeecc 100644 --- a/polkadot/network/src/lib.rs +++ b/polkadot/network/src/lib.rs @@ -47,7 +47,7 @@ mod collator_pool; mod router; pub mod consensus; -use codec::Slicable; +use codec::{Decode, Encode}; use futures::sync::oneshot; use parking_lot::Mutex; use polkadot_consensus::{Statement, SignedStatement, GenericStatement}; @@ -81,25 +81,25 @@ pub struct Status { collating_for: Option<(AccountId, ParaId)>, } -impl Slicable for Status { - fn encode(&self) -> Vec { - let mut v = Vec::new(); +impl Encode for Status { + fn encode_to(&self, dest: &mut T) { match self.collating_for { Some(ref details) => { - v.push(1); - details.using_encoded(|s| v.extend(s)); + dest.push_byte(1); + dest.push(details); } None => { - v.push(0); + dest.push_byte(0); } } - v } +} - fn decode(input: &mut I) -> Option { +impl Decode for Status { + fn decode(input: &mut I) -> Option { let collating_for = match input.read_byte()? { 0 => None, - 1 => Some(Slicable::decode(input)?), + 1 => Some(Decode::decode(input)?), _ => return None, }; Some(Status { collating_for }) diff --git a/polkadot/network/src/tests.rs b/polkadot/network/src/tests.rs index 5e3eca4651..95c24ae071 100644 --- a/polkadot/network/src/tests.rs +++ b/polkadot/network/src/tests.rs @@ -23,7 +23,7 @@ use polkadot_consensus::GenericStatement; use polkadot_primitives::{Block, Hash, SessionKey}; use polkadot_primitives::parachain::{CandidateReceipt, HeadData, BlockData}; use substrate_primitives::H512; -use codec::Slicable; +use codec::Encode; use substrate_network::{PeerId, PeerInfo, ClientHandle, Context, message::Message as SubstrateMessage, message::Role, specialization::Specialization, generic_message::Message as GenericMessage}; use std::sync::Arc; diff --git a/polkadot/parachain/src/lib.rs b/polkadot/parachain/src/lib.rs index 2f3c064f33..7af248fdbe 100644 --- a/polkadot/parachain/src/lib.rs +++ b/polkadot/parachain/src/lib.rs @@ -61,7 +61,7 @@ extern crate error_chain; #[cfg(not(feature = "std"))] use alloc::vec::Vec; -use codec::Slicable; +use codec::{Encode, Decode, Input, Output}; #[cfg(feature = "std")] pub mod wasm; @@ -77,20 +77,18 @@ pub struct ValidationParams { pub parent_head: Vec, } -impl Slicable for ValidationParams { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.block_data.using_encoded(|s| v.extend(s)); - self.parent_head.using_encoded(|s| v.extend(s)); - - v +impl Encode for ValidationParams { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.block_data); + dest.push(&self.parent_head); } +} - fn decode(input: &mut I) -> Option { +impl Decode for ValidationParams { + fn decode(input: &mut I) -> Option { Some(ValidationParams { - block_data: Slicable::decode(input)?, - parent_head: Slicable::decode(input)?, + block_data: Decode::decode(input)?, + parent_head: Decode::decode(input)?, }) } } @@ -104,14 +102,16 @@ pub struct ValidationResult { pub head_data: Vec } -impl Slicable for ValidationResult { - fn encode(&self) -> Vec { - self.head_data.encode() +impl Encode for ValidationResult { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.head_data); } +} - fn decode(input: &mut I) -> Option { +impl Decode for ValidationResult { + fn decode(input: &mut I) -> Option { Some(ValidationResult { - head_data: Slicable::decode(input)?, + head_data: Decode::decode(input)?, }) } } diff --git a/polkadot/parachain/src/wasm.rs b/polkadot/parachain/src/wasm.rs index a16383acb9..494f176a3d 100644 --- a/polkadot/parachain/src/wasm.rs +++ b/polkadot/parachain/src/wasm.rs @@ -20,7 +20,7 @@ //! Assuming the parameters are correct, this module provides a wrapper around //! a WASM VM for re-execution of a parachain candidate. -use codec::Slicable; +use codec::{Decode, Encode}; use wasmi::{self, Module, ModuleInstance, MemoryInstance, MemoryDescriptor, MemoryRef, ModuleImportResolver}; use wasmi::{memory_units, RuntimeValue}; diff --git a/polkadot/parachain/test-chains/basic_add/src/lib.rs b/polkadot/parachain/test-chains/basic_add/src/lib.rs index 7518072a1d..ff9006c8c2 100644 --- a/polkadot/parachain/test-chains/basic_add/src/lib.rs +++ b/polkadot/parachain/test-chains/basic_add/src/lib.rs @@ -33,7 +33,7 @@ extern crate wee_alloc; extern crate tiny_keccak; extern crate pwasm_libc; -use parachain::codec::{Slicable, Input}; +use parachain::codec::{Decode, Encode, Input, Output}; #[cfg(not(feature = "std"))] mod wasm; @@ -41,9 +41,6 @@ mod wasm; #[cfg(not(feature = "std"))] pub use wasm::*; -#[cfg(not(feature = "std"))] -use alloc::vec::Vec; - // Define global allocator. #[cfg(not(feature = "std"))] #[global_allocator] @@ -60,22 +57,20 @@ struct HeadData { post_state: [u8; 32], } -impl Slicable for HeadData { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.number.using_encoded(|s| v.extend(s)); - self.parent_hash.using_encoded(|s| v.extend(s)); - self.post_state.using_encoded(|s| v.extend(s)); - - v +impl Encode for HeadData { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.number); + dest.push(&self.parent_hash); + dest.push(&self.post_state); } +} +impl Decode for HeadData { fn decode(input: &mut I) -> Option { Some(HeadData { - number: Slicable::decode(input)?, - parent_hash: Slicable::decode(input)?, - post_state: Slicable::decode(input)?, + number: Decode::decode(input)?, + parent_hash: Decode::decode(input)?, + post_state: Decode::decode(input)?, }) } } @@ -89,20 +84,18 @@ struct BlockData { add: u64, } -impl Slicable for BlockData { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.state.using_encoded(|s| v.extend(s)); - self.add.using_encoded(|s| v.extend(s)); - - v +impl Encode for BlockData { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.state); + dest.push(&self.add); } +} +impl Decode for BlockData { fn decode(input: &mut I) -> Option { Some(BlockData { - state: Slicable::decode(input)?, - add: Slicable::decode(input)?, + state: Decode::decode(input)?, + add: Decode::decode(input)?, }) } } diff --git a/polkadot/parachain/test-chains/basic_add/src/wasm.rs b/polkadot/parachain/test-chains/basic_add/src/wasm.rs index 38a8aa81b5..1007113188 100644 --- a/polkadot/parachain/test-chains/basic_add/src/wasm.rs +++ b/polkadot/parachain/test-chains/basic_add/src/wasm.rs @@ -18,7 +18,7 @@ use core::{intrinsics, panic, alloc}; use parachain::{self, ValidationResult}; -use parachain::codec::Slicable; +use parachain::codec::{Encode, Decode}; use super::{HeadData, BlockData}; #[panic_implementation] diff --git a/polkadot/parachain/tests/basic_add.rs b/polkadot/parachain/tests/basic_add.rs index c5fbe467a4..566a6efc3f 100644 --- a/polkadot/parachain/tests/basic_add.rs +++ b/polkadot/parachain/tests/basic_add.rs @@ -20,7 +20,7 @@ extern crate polkadot_parachain as parachain; extern crate tiny_keccak; use parachain::ValidationParams; -use parachain::codec::{Slicable, Input}; +use parachain::codec::{Decode, Encode, Input, Output}; // Head data for this parachain. #[derive(Default, Clone)] @@ -33,22 +33,20 @@ struct HeadData { post_state: [u8; 32], } -impl Slicable for HeadData { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.number.using_encoded(|s| v.extend(s)); - self.parent_hash.using_encoded(|s| v.extend(s)); - self.post_state.using_encoded(|s| v.extend(s)); - - v +impl Encode for HeadData { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.number); + dest.push(&self.parent_hash); + dest.push(&self.post_state); } +} +impl Decode for HeadData { fn decode(input: &mut I) -> Option { Some(HeadData { - number: Slicable::decode(input)?, - parent_hash: Slicable::decode(input)?, - post_state: Slicable::decode(input)?, + number: Decode::decode(input)?, + parent_hash: Decode::decode(input)?, + post_state: Decode::decode(input)?, }) } } @@ -62,20 +60,18 @@ struct BlockData { add: u64, } -impl Slicable for BlockData { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.state.using_encoded(|s| v.extend(s)); - self.add.using_encoded(|s| v.extend(s)); - - v +impl Encode for BlockData { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.state); + dest.push(&self.add); } +} +impl Decode for BlockData { fn decode(input: &mut I) -> Option { Some(BlockData { - state: Slicable::decode(input)?, - add: Slicable::decode(input)?, + state: Decode::decode(input)?, + add: Decode::decode(input)?, }) } } diff --git a/polkadot/primitives/src/lib.rs b/polkadot/primitives/src/lib.rs index f7861a8337..83118799bb 100644 --- a/polkadot/primitives/src/lib.rs +++ b/polkadot/primitives/src/lib.rs @@ -42,7 +42,7 @@ use primitives::bytes; use rstd::prelude::*; use runtime_primitives::traits::BlakeTwo256; use runtime_primitives::generic; -use codec::{Input, Slicable}; +use codec::{Encode, Decode, Input, Output}; pub mod parachain; @@ -109,12 +109,14 @@ pub type BlockId = generic::BlockId; #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))] pub struct Log(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec); -impl Slicable for Log { +impl Decode for Log { fn decode(input: &mut I) -> Option { Vec::::decode(input).map(Log) } +} - fn using_encoded R>(&self, f: F) -> R { - self.0.using_encoded(f) +impl Encode for Log { + fn encode_to(&self, dest: &mut T) { + self.0.encode_to(dest) } } diff --git a/polkadot/primitives/src/parachain.rs b/polkadot/primitives/src/parachain.rs index bbf9591ee0..31ba646328 100644 --- a/polkadot/primitives/src/parachain.rs +++ b/polkadot/primitives/src/parachain.rs @@ -16,7 +16,7 @@ //! Polkadot parachain types. -use codec::{Slicable, Input}; +use codec::{Encode, Decode, Input, Output}; use rstd::prelude::*; use rstd::cmp::Ordering; use super::Hash; @@ -47,11 +47,13 @@ impl Id { } } -impl Slicable for Id { +impl Decode for Id { fn decode(input: &mut I) -> Option { u32::decode(input).map(Id) } +} +impl Encode for Id { fn using_encoded R>(&self, f: F) -> R { self.0.using_encoded(f) } @@ -67,30 +69,26 @@ pub enum Chain { Parachain(Id), } -impl Slicable for Chain { +impl Decode for Chain { fn decode(input: &mut I) -> Option { let disc = input.read_byte()?; match disc { 0 => Some(Chain::Relay), - 1 => Some(Chain::Parachain(Slicable::decode(input)?)), + 1 => Some(Chain::Parachain(Decode::decode(input)?)), _ => None, } } +} - fn encode(&self) -> Vec { - let mut v = Vec::new(); +impl Encode for Chain { + fn encode_to(&self, dest: &mut T) { match *self { - Chain::Relay => { v.push(0); } + Chain::Relay => { dest.push_byte(0); } Chain::Parachain(id) => { - v.push(1u8); - id.using_encoded(|s| v.extend(s)); + dest.push_byte(1u8); + dest.push(&id); } } - v - } - - fn using_encoded R>(&self, f: F) -> R { - f(&self.encode().as_slice()) } } @@ -105,25 +103,19 @@ pub struct DutyRoster { pub guarantor_duty: Vec, } -impl Slicable for DutyRoster { +impl Decode for DutyRoster { fn decode(input: &mut I) -> Option { Some(DutyRoster { - validator_duty: Slicable::decode(input)?, - guarantor_duty: Slicable::decode(input)?, + validator_duty: Decode::decode(input)?, + guarantor_duty: Decode::decode(input)?, }) } +} - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - v.extend(self.validator_duty.encode()); - v.extend(self.guarantor_duty.encode()); - - v - } - - fn using_encoded R>(&self, f: F) -> R { - f(&self.encode().as_slice()) +impl Encode for DutyRoster { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.validator_duty); + dest.push(&self.guarantor_duty); } } @@ -158,32 +150,30 @@ pub struct CandidateReceipt { pub block_data_hash: Hash, } -impl Slicable for CandidateReceipt { - fn encode(&self) -> Vec { - let mut v = Vec::new(); - - self.parachain_index.using_encoded(|s| v.extend(s)); - self.collator.using_encoded(|s| v.extend(s)); - self.signature.using_encoded(|s| v.extend(s)); - self.head_data.0.using_encoded(|s| v.extend(s)); - self.balance_uploads.using_encoded(|s| v.extend(s)); - self.egress_queue_roots.using_encoded(|s| v.extend(s)); - self.fees.using_encoded(|s| v.extend(s)); - self.block_data_hash.using_encoded(|s| v.extend(s)); - - v +impl Encode for CandidateReceipt { + fn encode_to(&self, dest: &mut T) { + dest.push(&self.parachain_index); + dest.push(&self.collator); + dest.push(&self.signature); + dest.push(&self.head_data.0); + dest.push(&self.balance_uploads); + dest.push(&self.egress_queue_roots); + dest.push(&self.fees); + dest.push(&self.block_data_hash); } +} +impl Decode for CandidateReceipt { fn decode(input: &mut I) -> Option { Some(CandidateReceipt { - parachain_index: Slicable::decode(input)?, - collator: Slicable::decode(input)?, - signature: Slicable::decode(input)?, - head_data: Slicable::decode(input).map(HeadData)?, - balance_uploads: Slicable::decode(input)?, - egress_queue_roots: Slicable::decode(input)?, - fees: Slicable::decode(input)?, - block_data_hash: Slicable::decode(input)?, + parachain_index: Decode::decode(input)?, + collator: Decode::decode(input)?, + signature: Decode::decode(input)?, + head_data: Decode::decode(input).map(HeadData)?, + balance_uploads: Decode::decode(input)?, + egress_queue_roots: Decode::decode(input)?, + fees: Decode::decode(input)?, + block_data_hash: Decode::decode(input)?, }) } } @@ -283,13 +273,15 @@ pub struct ValidationCode(#[cfg_attr(feature = "std", serde(with="bytes"))] pub #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))] pub struct Activity(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec); -impl Slicable for Activity { +impl Decode for Activity { fn decode(input: &mut I) -> Option { Vec::::decode(input).map(Activity) } +} - fn using_encoded R>(&self, f: F) -> R { - self.0.using_encoded(f) +impl Encode for Activity { + fn encode_to(&self, dest: &mut T) { + self.0.encode_to(dest) } } diff --git a/polkadot/runtime/src/lib.rs b/polkadot/runtime/src/lib.rs index b74e5754e0..9ccafe92a9 100644 --- a/polkadot/runtime/src/lib.rs +++ b/polkadot/runtime/src/lib.rs @@ -257,7 +257,7 @@ pub mod api { mod tests { use super::*; use substrate_primitives as primitives; - use ::codec::Slicable; + use codec::{Encode, Decode}; use substrate_primitives::hexdisplay::HexDisplay; use substrate_serializer as ser; use runtime_primitives::traits::{Digest as DigestT, Header as HeaderT}; @@ -376,7 +376,7 @@ mod tests { // df0f0200 // 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 - let v = Slicable::encode(&tx); + let v = Encode::encode(&tx); assert_eq!(&v[..], &hex!["6f000000ff0101010101010101010101010101010101010101010101010101010101010101e70300000300df0f02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"][..]); println!("{}", HexDisplay::from(&v)); assert_eq!(UncheckedExtrinsic::decode(&mut &v[..]).unwrap(), tx); @@ -393,7 +393,7 @@ mod tests { )) ))), }; - let v = Slicable::encode(&xt); + let v = Encode::encode(&xt); assert_eq!(Extrinsic::decode(&mut &v[..]).unwrap(), xt); } diff --git a/polkadot/runtime/src/parachains.rs b/polkadot/runtime/src/parachains.rs index 809ff0396b..bd62f9895e 100644 --- a/polkadot/runtime/src/parachains.rs +++ b/polkadot/runtime/src/parachains.rs @@ -17,7 +17,7 @@ //! Main parachains logic. For now this is just the determination of which validators do what. use rstd::prelude::*; -use codec::Slicable; +use codec::Decode; use runtime_primitives::traits::{Hash, BlakeTwo256, Executable, RefInto, MaybeEmpty}; use primitives::parachain::{Id, Chain, DutyRoster, CandidateReceipt}; @@ -217,7 +217,7 @@ impl runtime_primitives::BuildStorage for GenesisConfig fn build_storage(mut self) -> ::std::result::Result { use std::collections::HashMap; use runtime_io::twox_128; - use codec::Slicable; + use codec::Encode; self.parachains.sort_unstable_by_key(|&(ref id, _)| id.clone()); self.parachains.dedup_by_key(|&mut (ref id, _)| id.clone()); diff --git a/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm b/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm index 37e839bedc..6ce4978078 100644 Binary files a/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm and b/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm differ diff --git a/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.wasm b/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.wasm index 2d63fb063f..6b4f396ef9 100755 Binary files a/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.wasm and b/polkadot/runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.wasm differ diff --git a/polkadot/service/src/lib.rs b/polkadot/service/src/lib.rs index 5c155a098e..a9952261a0 100644 --- a/polkadot/service/src/lib.rs +++ b/polkadot/service/src/lib.rs @@ -43,7 +43,7 @@ pub mod chain_spec; use std::sync::Arc; use std::collections::HashMap; -use codec::Slicable; +use codec::Encode; use transaction_pool::TransactionPool; use polkadot_api::{PolkadotApi, light::RemotePolkadotApiWrapper}; use polkadot_primitives::{Block, BlockId, Hash}; @@ -265,7 +265,7 @@ impl network::TransactionPool for TransactionPoolAdapter Some(*xt.hash()), diff --git a/polkadot/statement-table/src/generic.rs b/polkadot/statement-table/src/generic.rs index 8e7fa48e2e..56740288f8 100644 --- a/polkadot/statement-table/src/generic.rs +++ b/polkadot/statement-table/src/generic.rs @@ -31,7 +31,7 @@ use std::collections::hash_map::{HashMap, Entry}; use std::hash::Hash; use std::fmt::Debug; -use codec::{Slicable, Input}; +use codec::{Decode, Encode, Input, Output}; /// Context for the statement table. pub trait Context { @@ -97,44 +97,43 @@ enum StatementKind { Available = 4, } -impl Slicable for Statement { - fn encode(&self) -> Vec { - let mut v = Vec::new(); +impl Encode for Statement { + fn encode_to(&self, dest: &mut T) { match *self { Statement::Candidate(ref candidate) => { - v.push(StatementKind::Candidate as u8); - candidate.using_encoded(|s| v.extend(s)); + dest.push_byte(StatementKind::Candidate as u8); + dest.push(candidate); } Statement::Valid(ref digest) => { - v.push(StatementKind::Valid as u8); - digest.using_encoded(|s| v.extend(s)); + dest.push_byte(StatementKind::Valid as u8); + dest.push(digest); } Statement::Invalid(ref digest) => { - v.push(StatementKind::Invalid as u8); - digest.using_encoded(|s| v.extend(s)); + dest.push_byte(StatementKind::Invalid as u8); + dest.push(digest); } Statement::Available(ref digest) => { - v.push(StatementKind::Available as u8); - digest.using_encoded(|s| v.extend(s)); + dest.push_byte(StatementKind::Available as u8); + dest.push(digest); } } - - v } +} +impl Decode for Statement { fn decode(value: &mut I) -> Option { match value.read_byte() { Some(x) if x == StatementKind::Candidate as u8 => { - Slicable::decode(value).map(Statement::Candidate) + Decode::decode(value).map(Statement::Candidate) } Some(x) if x == StatementKind::Valid as u8 => { - Slicable::decode(value).map(Statement::Valid) + Decode::decode(value).map(Statement::Valid) } Some(x) if x == StatementKind::Invalid as u8 => { - Slicable::decode(value).map(Statement::Invalid) + Decode::decode(value).map(Statement::Invalid) } Some(x) if x == StatementKind::Available as u8 => { - Slicable::decode(value).map(Statement::Available) + Decode::decode(value).map(Statement::Available) } _ => None, } diff --git a/polkadot/transaction-pool/src/lib.rs b/polkadot/transaction-pool/src/lib.rs index ee0b506f6f..75a4eb0dac 100644 --- a/polkadot/transaction-pool/src/lib.rs +++ b/polkadot/transaction-pool/src/lib.rs @@ -43,7 +43,7 @@ use std::{ sync::Arc, }; -use codec::Slicable; +use codec::{Decode, Encode}; use extrinsic_pool::{Pool, Listener, txpool::{self, Readiness, scoring::{Change, Choice}}}; use extrinsic_pool::api::{ExtrinsicPool, EventStream}; use polkadot_api::PolkadotApi; @@ -75,7 +75,7 @@ impl VerifiedTransaction { /// Convert to primitive unchecked extrinsic. pub fn primitive_extrinsic(&self) -> ::primitives::UncheckedExtrinsic { - Slicable::decode(&mut self.as_transaction().encode().as_slice()) + Decode::decode(&mut self.as_transaction().encode().as_slice()) .expect("UncheckedExtrinsic shares repr with Vec; qed") } @@ -418,7 +418,7 @@ mod tests { use std::sync::{atomic::{self, AtomicBool}, Arc}; use super::TransactionPool; use substrate_keyring::Keyring::{self, *}; - use codec::Slicable; + use codec::{Decode, Encode}; use polkadot_api::{PolkadotApi, BlockBuilder, Result}; use primitives::{AccountId, AccountIndex, Block, BlockId, Hash, Index, SessionKey, Timestamp, UncheckedExtrinsic as FutureProofUncheckedExtrinsic};