Modularised dispatch

demo/executor/src/lib.rs

@@ -41,11 +41,13 @@ mod tests {
  use codec::{KeyedVec, Slicable, Joiner};
  use keyring::Keyring::{self, Alice, Bob};
  use runtime_support::Hashable;
- use demo_runtime::runtime::staking::{self, balance, BALANCE_OF};
  use state_machine::{CodeExecutor, TestExternalities};
  use primitives::twox_128;
- use demo_primitives::{Hash, Header, BlockNumber, Block, Digest, Transaction,
- UncheckedTransaction, Function};
+ use demo_primitives::{Hash, Header, BlockNumber, Digest};
+ use demo_runtime::transaction::{Transaction, UncheckedTransaction};
+ use demo_runtime::block::Block;
+ use demo_runtime::runtime::staking::{self, balance, BALANCE_OF};
+ use demo_runtime::dispatch;
  use ed25519::{Public, Pair};
 
  const BLOATY_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
@@ -62,7 +64,7 @@ mod tests {
  let transaction = Transaction {
  signed: Alice.into(),
  nonce: 0,
- function: Function::StakingTransfer(Bob.into(), 69),
+ function: dispatch::PubCall::Staking(staking::public::Call::transfer(Bob.into(), 69)),
  };
  let signature = Keyring::from_raw_public(transaction.signed).unwrap()
  .sign(&transaction.encode());
@@ -73,7 +75,8 @@ mod tests {
  #[test]
  fn panic_execution_with_foreign_code_gives_error() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
@@ -83,7 +86,8 @@ mod tests {
  #[test]
  fn panic_execution_with_native_equivalent_code_gives_error() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
@@ -93,7 +97,8 @@ mod tests {
  #[test]
  fn successful_execution_with_native_equivalent_code_gives_ok() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
@@ -108,7 +113,8 @@ mod tests {
  #[test]
  fn successful_execution_with_foreign_code_gives_ok() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
@@ -152,11 +158,11 @@ mod tests {
  construct_block(
  1,
  [69u8; 32].into(),
- hex!("970ae19447bef129c88ee80c72797fa9dfeda4ca1a26d10102b669d776eb0ccf").into(),
+ hex!("cfb76a83e40aa6a0d3f92255e6229e74808cae31d9f46053f31129b797540d03").into(),
  vec![Transaction {
  signed: Alice.into(),
  nonce: 0,
- function: Function::StakingTransfer(Bob.into(), 69),
+ function: dispatch::PubCall::Staking(staking::public::Call::transfer(Bob.into(), 69)),
  }]
  )
  }
@@ -165,17 +171,17 @@ mod tests {
  construct_block(
  2,
  block1().1,
- hex!("347ece6ef0d193bd7c2bfbda17706b82eb24c0965f415784a44b138f0df034cd").into(),
+ hex!("c713bd003e303648e8d904bcfa44084865c9b70c398547e678028cc7cf60907f").into(),
  vec![
  Transaction {
  signed: Bob.into(),
  nonce: 0,
- function: Function::StakingTransfer(Alice.into(), 5),
+ function: dispatch::PubCall::Staking(staking::public::Call::transfer(Alice.into(), 5)),
  },
  Transaction {
  signed: Alice.into(),
  nonce: 1,
- function: Function::StakingTransfer(Bob.into(), 15),
+ function: dispatch::PubCall::Staking(staking::public::Call::transfer(Bob.into(), 15)),
  }
  ]
  )
@@ -188,15 +194,15 @@ mod tests {
  Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
  runtime_io::with_externalities(&mut t, || {
- assert_eq!(balance(&Alice), 42);
+ assert_eq!(balance(&Alice), 41);
  assert_eq!(balance(&Bob), 69);
  });
 
  Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
  runtime_io::with_externalities(&mut t, || {
- assert_eq!(balance(&Alice), 32);
- assert_eq!(balance(&Bob), 79);
+ assert_eq!(balance(&Alice), 30);
+ assert_eq!(balance(&Bob), 78);
  });
  }
 
@@ -207,22 +213,23 @@ mod tests {
  WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
  runtime_io::with_externalities(&mut t, || {
- assert_eq!(balance(&Alice), 42);
+ assert_eq!(balance(&Alice), 41);
  assert_eq!(balance(&Bob), 69);
  });
 
  WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
  runtime_io::with_externalities(&mut t, || {
- assert_eq!(balance(&Alice), 32);
- assert_eq!(balance(&Bob), 79);
+ assert_eq!(balance(&Alice), 30);
+ assert_eq!(balance(&Bob), 78);
  });
  }
 
  #[test]
  fn panic_execution_gives_error() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
@@ -233,7 +240,8 @@ mod tests {
  #[test]
  fn successful_execution_gives_ok() {
  let mut t: TestExternalities = map![
- twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+ twox_128(&Alice.to_raw_public().to_keyed_vec(BALANCE_OF)).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0],
+ twox_128(staking::TRANSACTION_FEE).to_vec() => vec![0u8; 8]
  ];
 
  let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm");

demo/primitives/src/block.rs

@@ -21,7 +21,6 @@ use primitives::bytes;
 use primitives::H256;
 use rstd::vec::Vec;
 use codec::{Input, Slicable};
-use transaction::UncheckedTransaction;
 
 pub use primitives::block::Id;
 
@@ -31,9 +30,6 @@ 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))]
@@ -69,35 +65,6 @@ impl Slicable for Digest {
  }
 }
 
-/// The block "body": A bunch of transactions.
-pub type Body = Vec<UncheckedTransaction>;
-
-/// A block on the chain.
-#[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
- }
-}
-
 /// Header for a block.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]

demo/primitives/src/lib.rs

@@ -45,11 +45,9 @@ macro_rules! try_opt {
 }
 
 pub mod block;
-pub mod transaction;
 
-pub use self::block::{Header, Block, Log, Digest};
+pub use self::block::{Header, Log, Digest};
 pub use self::block::Number as BlockNumber;
-pub use self::transaction::{Transaction, UncheckedTransaction, Function, Proposal, VoteThreshold};
 
 /// 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`.