Introduce substrate-demo

substrate/demo/primitives/src/block.rs

@@ -0,0 +1,189 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate Demo is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Block and header type definitions.
+
+#[cfg(feature = "std")]
+use primitives::bytes;
+use primitives::H256;
+use rstd::vec::Vec;
+use codec::{Input, Slicable};
+use transaction::UncheckedTransaction;
+
+pub use primitives::block::Id;
+
+/// Used to refer to a block number.
+pub type Number = u64;
+
+/// Hash used to refer to a block hash.
+pub type HeaderHash = H256;
+
+/// Hash used to refer to a transaction hash.
+pub type TransactionHash = H256;
+
+/// Execution log (event)
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Log(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+impl Slicable for Log {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Vec::<u8>::decode(input).map(Log)
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(f)
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Log { }
+
+/// The digest of a block, useful for light-clients.
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Digest {
+	/// All logs that have happened in the block.
+	pub logs: Vec<Log>,
+}
+
+impl Slicable for Digest {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Vec::<Log>::decode(input).map(|logs| Digest { logs })
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.logs.using_encoded(f)
+	}
+}
+
+/// The block "body": A bunch of transactions.
+pub type Body = Vec<UncheckedTransaction>;
+
+/// A Polkadot relay chain block.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Block {
+	/// The block header.
+	pub header: Header,
+	/// All relay-chain transactions.
+	pub transactions: Body,
+}
+
+impl Slicable for Block {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let (header, transactions) = try_opt!(Slicable::decode(input));
+		Some(Block { header, transactions })
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		v.extend(self.header.encode());
+		v.extend(self.transactions.encode());
+
+		v
+	}
+}
+
+/// A relay chain block header.
+///
+/// https://github.com/w3f/polkadot-spec/blob/master/spec.md#header
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct Header {
+	/// Block parent's hash.
+	pub parent_hash: HeaderHash,
+	/// Block number.
+	pub number: Number,
+	/// State root after this transition.
+	pub state_root: H256,
+	/// The root of the trie that represents this block's transactions, indexed by a 32-byte integer.
+	pub transaction_root: H256,
+	/// The digest of activity on the block.
+	pub digest: Digest,
+}
+
+impl Header {
+	/// Create a new instance with default fields except `number`, which is given as an argument.
+	pub fn from_block_number(number: Number) -> Self {
+		Header {
+			parent_hash: Default::default(),
+			number,
+			state_root: Default::default(),
+			transaction_root: Default::default(),
+			digest: Default::default(),
+		}
+	}
+}
+
+impl Slicable for Header {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Header {
+			parent_hash: try_opt!(Slicable::decode(input)),
+			number: try_opt!(Slicable::decode(input)),
+			state_root: try_opt!(Slicable::decode(input)),
+			transaction_root: try_opt!(Slicable::decode(input)),
+			digest: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.parent_hash.using_encoded(|s| v.extend(s));
+		self.number.using_encoded(|s| v.extend(s));
+		self.state_root.using_encoded(|s| v.extend(s));
+		self.transaction_root.using_encoded(|s| v.extend(s));
+		self.digest.using_encoded(|s| v.extend(s));
+
+		v
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Slicable;
+	use substrate_serializer as ser;
+
+	#[test]
+	fn test_header_serialization() {
+		let header = Header {
+			parent_hash: 5.into(),
+			number: 67,
+			state_root: 3.into(),
+			transaction_root: 6.into(),
+			digest: Digest { logs: vec![Log(vec![1])] },
+		};
+
+		assert_eq!(ser::to_string_pretty(&header), r#"{
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000005",
+  "number": 67,
+  "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000003",
+  "transactionRoot": "0x0000000000000000000000000000000000000000000000000000000000000006",
+  "digest": {
+    "logs": [
+      "0x01"
+    ]
+  }
+}"#);
+
+		let v = header.encode();
+		assert_eq!(Header::decode(&mut &v[..]).unwrap(), header);
+	}
+}

substrate/demo/primitives/src/lib.rs

@@ -0,0 +1,77 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate Demo is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Shareable Polkadot types.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+#[cfg(feature = "std")]
+extern crate serde;
+
+extern crate substrate_runtime_std as rstd;
+extern crate substrate_primitives as primitives;
+#[cfg(test)]
+extern crate substrate_serializer;
+
+extern crate substrate_codec as codec;
+
+macro_rules! try_opt {
+	($e: expr) => {
+		match $e {
+			Some(x) => x,
+			None => return None,
+		}
+	}
+}
+
+pub mod block;
+pub mod transaction;
+
+pub use self::block::{Header, Block, Log, Digest};
+pub use self::block::Number as BlockNumber;
+pub use self::transaction::{Transaction, UncheckedTransaction, Function, Proposal};
+
+/// Virtual account ID that represents the idea of a dispatch/statement being signed by everybody
+/// (who matters). Essentially this means that a majority of validators have decided it is
+/// "correct".
+pub const EVERYBODY: AccountId = [255u8; 32];
+
+/// Alias to Ed25519 pubkey that identifies an account on the relay chain. This will almost
+/// certainly continue to be the same as the substrate's `AuthorityId`.
+pub type AccountId = primitives::AuthorityId;
+
+/// The Ed25519 pub key of an session that belongs to an authority of the relay chain. This is
+/// exactly equivalent to what the substrate calls an "authority".
+pub type SessionKey = primitives::AuthorityId;
+
+/// Indentifier for a chain.
+pub type ChainID = u64;
+
+/// Index of a transaction in the relay chain.
+pub type TxOrder = u64;
+
+/// A hash of some data used by the relay chain.
+pub type Hash = primitives::H256;
+
+/// Alias to 520-bit hash when used in the context of a signature on the relay chain.
+pub type Signature = primitives::hash::H512;

substrate/demo/primitives/src/transaction.rs

@@ -0,0 +1,390 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate Demo is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Transaction type.
+
+use rstd::vec::Vec;
+use codec::{Input, Slicable};
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+use block::Number as BlockNumber;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum InternalFunctionId {
+	/// Set the system's code.
+	SystemSetCode = 0x00,
+
+	/// Set the session length.
+	SessionSetLength = 0x10,
+	/// Force a new session.
+	SessionForceNewSession = 0x11,
+
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra = 0x20,
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration = 0x21,
+	/// Set the validator count for staking.
+	StakingSetValidatorCount = 0x22,
+	/// Force a new staking era.
+	StakingForceNewEra = 0x23,
+
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired = 0x30,
+
+}
+
+impl InternalFunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<InternalFunctionId> {
+		let functions = [
+			InternalFunctionId::SystemSetCode,
+			InternalFunctionId::SessionSetLength,
+			InternalFunctionId::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra,
+			InternalFunctionId::StakingSetBondingDuration,
+			InternalFunctionId::StakingSetValidatorCount,
+			InternalFunctionId::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired,
+		];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Internal functions that can be dispatched to.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Proposal {
+	/// Set the system's code.
+	SystemSetCode(Vec<u8>),
+	/// Set the session length.
+	SessionSetLength(BlockNumber),
+	/// Force a new session.
+	SessionForceNewSession,
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra(BlockNumber),
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration(BlockNumber),
+	/// Set the validator count for staking.
+	StakingSetValidatorCount(u32),
+	/// Force a new staking era.
+	StakingForceNewEra,
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired(u32),
+
+}
+
+impl Slicable for Proposal {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let id = try_opt!(u8::decode(input).and_then(InternalFunctionId::from_u8));
+		let function = match id {
+			InternalFunctionId::SystemSetCode =>
+				Proposal::SystemSetCode(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::SessionSetLength =>
+				Proposal::SessionSetLength(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::SessionForceNewSession => Proposal::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra =>
+				Proposal::StakingSetSessionsPerEra(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingSetBondingDuration =>
+				Proposal::StakingSetBondingDuration(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingSetValidatorCount =>
+				Proposal::StakingSetValidatorCount(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingForceNewEra => Proposal::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired =>
+				Proposal::GovernanceSetApprovalPpmRequired(try_opt!(Slicable::decode(input))),
+		};
+
+		Some(function)
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Proposal::SystemSetCode(ref data) => {
+				(InternalFunctionId::SystemSetCode as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::SessionSetLength(ref data) => {
+				(InternalFunctionId::SessionSetLength as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::SessionForceNewSession => {
+				(InternalFunctionId::SessionForceNewSession as u8).using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetSessionsPerEra(ref data) => {
+				(InternalFunctionId::StakingSetSessionsPerEra as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetBondingDuration(ref data) => {
+				(InternalFunctionId::StakingSetBondingDuration as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetValidatorCount(ref data) => {
+				(InternalFunctionId::StakingSetValidatorCount as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingForceNewEra => {
+				(InternalFunctionId::StakingForceNewEra as u8).using_encoded(|s| v.extend(s));
+			}
+			Proposal::GovernanceSetApprovalPpmRequired(ref data) => {
+				(InternalFunctionId::GovernanceSetApprovalPpmRequired as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+}
+
+/// Public functions that can be dispatched to.
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum FunctionId {
+	/// Set the timestamp.
+	TimestampSet = 0x00,
+	/// Set temporary session key as a validator.
+	SessionSetKey = 0x10,
+	/// Staking subsystem: begin staking.
+	StakingStake = 0x20,
+	/// Staking subsystem: stop staking.
+	StakingUnstake = 0x21,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer = 0x22,
+	/// Make a proposal for the governance system.
+	GovernancePropose = 0x30,
+	/// Approve a proposal for the governance system.
+	GovernanceApprove = 0x31,
+}
+
+impl FunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<FunctionId> {
+		use self::*;
+		let functions = [FunctionId::StakingStake, FunctionId::StakingUnstake,
+			FunctionId::StakingTransfer, FunctionId::SessionSetKey, FunctionId::TimestampSet,
+			FunctionId::GovernancePropose, FunctionId::GovernanceApprove];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Functions on the runtime.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Function {
+	/// Set the timestamp.
+	TimestampSet(u64),
+	/// Set temporary session key as a validator.
+	SessionSetKey(::SessionKey),
+	/// Staking subsystem: begin staking.
+	StakingStake,
+	/// Staking subsystem: stop staking.
+	StakingUnstake,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer(::AccountId, u64),
+	/// Make a proposal for the governance system.
+	GovernancePropose(Proposal),
+	/// Approve a proposal for the governance system.
+	GovernanceApprove(BlockNumber),
+}
+
+impl Slicable for Function {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let id = try_opt!(u8::decode(input).and_then(FunctionId::from_u8));
+		Some(match id {
+			FunctionId::TimestampSet =>
+				Function::TimestampSet(try_opt!(Slicable::decode(input))),
+			FunctionId::SessionSetKey =>
+				Function::SessionSetKey(try_opt!(Slicable::decode(input))),
+			FunctionId::StakingStake => Function::StakingStake,
+			FunctionId::StakingUnstake => Function::StakingUnstake,
+			FunctionId::StakingTransfer => {
+				let to  = try_opt!(Slicable::decode(input));
+				let amount = try_opt!(Slicable::decode(input));
+
+				Function::StakingTransfer(to, amount)
+			}
+			FunctionId::GovernancePropose =>
+				Function::GovernancePropose(try_opt!(Slicable::decode(input))),
+			FunctionId::GovernanceApprove =>
+				Function::GovernanceApprove(try_opt!(Slicable::decode(input))),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Function::TimestampSet(ref data) => {
+				(FunctionId::TimestampSet as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::SessionSetKey(ref data) => {
+				(FunctionId::SessionSetKey as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::StakingStake => {
+				(FunctionId::StakingStake as u8).using_encoded(|s| v.extend(s));
+			}
+			Function::StakingUnstake => {
+				(FunctionId::StakingUnstake as u8).using_encoded(|s| v.extend(s));
+			}
+			Function::StakingTransfer(ref to, ref amount) => {
+				(FunctionId::StakingTransfer as u8).using_encoded(|s| v.extend(s));
+				to.using_encoded(|s| v.extend(s));
+				amount.using_encoded(|s| v.extend(s));
+			}
+			Function::GovernancePropose(ref data) => {
+				(FunctionId::GovernancePropose as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::GovernanceApprove(ref data) => {
+				(FunctionId::GovernanceApprove as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.encode().as_slice())
+	}
+}
+
+/// A vetted and verified transaction from the external world.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Transaction {
+	/// Who signed it (note this is not a signature).
+	pub signed: super::AccountId,
+	/// The number of transactions have come before from the same signer.
+	pub nonce: super::TxOrder,
+	/// The function that should be called.
+	pub function: Function,
+}
+
+impl Slicable for Transaction {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Transaction {
+			signed: try_opt!(Slicable::decode(input)),
+			nonce: try_opt!(Slicable::decode(input)),
+			function: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.signed.using_encoded(|s| v.extend(s));
+		self.nonce.using_encoded(|s| v.extend(s));
+		self.function.using_encoded(|s| v.extend(s));
+
+		v
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Transaction {}
+
+/// A transactions right from the external world. Unchecked.
+#[derive(Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct UncheckedTransaction {
+	/// The actual transaction information.
+	pub transaction: Transaction,
+	/// The signature; should be an Ed25519 signature applied to the serialised `transaction` field.
+	pub signature: super::Signature,
+}
+
+impl Slicable for UncheckedTransaction {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		// This is a little more complicated than usual since the binary format must be compatible
+		// with substrate's generic `Vec<u8>` type. Basically this just means accepting that there
+		// will be a prefix of u32, which has the total number of bytes following (we don't need
+		// to use this).
+		let _length_do_not_remove_me_see_above: u32 = try_opt!(Slicable::decode(input));
+
+		Some(UncheckedTransaction {
+			transaction: try_opt!(Slicable::decode(input)),
+			signature: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		// need to prefix with the total length as u32 to ensure it's binary comptible with
+		// Vec<u8>. we'll make room for it here, then overwrite once we know the length.
+		v.extend(&[0u8; 4]);
+
+		self.transaction.signed.using_encoded(|s| v.extend(s));
+		self.transaction.nonce.using_encoded(|s| v.extend(s));
+		self.transaction.function.using_encoded(|s| v.extend(s));
+		self.signature.using_encoded(|s| v.extend(s));
+
+		let length = (v.len() - 4) as u32;
+		length.using_encoded(|s| v[0..4].copy_from_slice(s));
+
+		v
+	}
+}
+
+impl ::codec::NonTrivialSlicable for UncheckedTransaction {}
+
+impl PartialEq for UncheckedTransaction {
+	fn eq(&self, other: &Self) -> bool {
+		self.signature.iter().eq(other.signature.iter()) && self.transaction == other.transaction
+	}
+}
+
+#[cfg(feature = "std")]
+impl fmt::Debug for UncheckedTransaction {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "UncheckedTransaction({:?})", self.transaction)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use primitives;
+	use ::codec::Slicable;
+	use primitives::hexdisplay::HexDisplay;
+
+	#[test]
+	fn serialize_unchecked() {
+		let tx = UncheckedTransaction {
+			transaction: Transaction {
+				signed: [1; 32],
+				nonce: 999u64,
+				function: Function::TimestampSet(135135),
+			},
+			signature: primitives::hash::H512([0; 64]),
+		};
+		// 71000000
+		// 0101010101010101010101010101010101010101010101010101010101010101
+		// e703000000000000
+		// 00
+		// df0f0200
+		// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+		let v = Slicable::encode(&tx);
+		println!("{}", HexDisplay::from(&v));
+		assert_eq!(UncheckedTransaction::decode(&mut &v[..]).unwrap(), tx);
+	}
+}