kill post_finalise (#121)

* kill post_finalise

* update wasm runtimes

demo/cli/src/lib.rs

@@ -125,10 +125,6 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
  let prepare_genesis = || {
  storage = genesis_config.build_externalities();
  let block = genesis::construct_genesis_block(&storage);
- with_externalities(&mut storage, ||
- // TODO: use api.rs to dispatch instead
- demo_runtime::System::initialise_genesis_state(&block.header)
- );
  (primitives::block::Header::decode(&mut block.header.encode().as_ref()).expect("to_vec() always gives a valid serialisation; qed"), storage.into_iter().collect())
  };
  let client = Arc::new(client::new_in_mem(executor, prepare_genesis)?);

polkadot/api/src/lib.rs

@@ -192,7 +192,16 @@ impl<B: Backend> PolkadotApi for Client<B, NativeExecutor<LocalDispatch>>
  }
 
  fn duty_roster(&self, at: &CheckedId) -> Result<DutyRoster> {
- with_runtime!(self, at, ::runtime::Parachains::calculate_duty_roster)
+ // duty roster can only be queried at the start of a block,
+ // so we create a dummy.
+ let id = at.block_id();
+ let parent_hash = self.block_hash_from_id(id)?.ok_or(ErrorKind::UnknownBlock(*id))?;
+ let number = self.block_number_from_id(id)?.ok_or(ErrorKind::UnknownBlock(*id))? + 1;
+
+ with_runtime!(self, at, || {
+ ::runtime::System::initialise(&number, &parent_hash, &Default::default());
+ ::runtime::Parachains::calculate_duty_roster()
+ })
  }
 
  fn timestamp(&self, at: &CheckedId) -> Result<Timestamp> {
@@ -203,7 +212,7 @@ impl<B: Backend> PolkadotApi for Client<B, NativeExecutor<LocalDispatch>>
  with_runtime!(self, at, || ::runtime::Executive::execute_block(block))
  }
 
- fn index(&self, at: &Self::CheckedBlockId, account: AccountId) -> Result<Index> {
+ fn index(&self, at: &CheckedId, account: AccountId) -> Result<Index> {
  with_runtime!(self, at, || ::runtime::System::account_index(account))
  }
 
@@ -381,10 +390,6 @@ mod tests {
  || {
  let mut storage = genesis_config.build_externalities();
  let block = ::client::genesis::construct_genesis_block(&storage);
- with_externalities(&mut storage, ||
- // TODO: use api.rs to dispatch instead
- runtime::System::initialise_genesis_state(&block.header)
- );
  (substrate_primitives::block::Header::decode(&mut block.header.encode().as_ref()).expect("to_vec() always gives a valid serialisation; qed"), storage.into_iter().collect())
  }
  ).unwrap()

polkadot/consensus/src/error.rs

@@ -16,8 +16,7 @@
 
 //! Errors that can occur during the consensus process.
 
-use primitives::block::HeaderHash;
-
+use primitives::block::{HeaderHash, Number};
 error_chain! {
  links {
  PolkadotApi(::polkadot_api::Error, ::polkadot_api::ErrorKind);
@@ -41,6 +40,10 @@ error_chain! {
  description("Proposal had wrong parent hash."),
  display("Proposal had wrong parent hash. Expected {:?}, got {:?}", expected, got),
  }
+ WrongNumber(expected: Number, got: Number) {
+ description("Proposal had wrong number."),
+ display("Proposal had wrong number. Expected {:?}, got {:?}", expected, got),
+ }
  ProposalTooLarge(size: usize) {
  description("Proposal exceeded the maximum size."),
  display(

polkadot/consensus/src/lib.rs

@@ -575,15 +575,15 @@ impl<C: PolkadotApi, R: TableRouter> bft::Proposer for Proposer<C, R> {
  let substrate_block = Slicable::decode(&mut polkadot_block.encode().as_slice())
  .expect("polkadot blocks defined to serialize to substrate blocks correctly; qed");
 
- assert!(evaluate_proposal(&substrate_block, &*self.client, current_timestamp(), &self.parent_hash, &self.parent_id).is_ok());
+ assert!(evaluate_proposal(&substrate_block, &*self.client, current_timestamp(), &self.parent_hash, self.parent_number, &self.parent_id).is_ok());
 
  Ok(substrate_block)
  }
 
  // TODO: certain kinds of errors here should lead to a misbehavior report.
  fn evaluate(&self, proposal: &SubstrateBlock) -> Result<bool, Error> {
  debug!(target: "bft", "evaluating block on top of parent ({}, {:?})", self.parent_number, self.parent_hash);
- match evaluate_proposal(proposal, &*self.client, current_timestamp(), &self.parent_hash, &self.parent_id) {
+ match evaluate_proposal(proposal, &*self.client, current_timestamp(), &self.parent_hash, self.parent_number, &self.parent_id) {
  Ok(x) => Ok(x),
  Err(e) => match *e.kind() {
  ErrorKind::PolkadotApi(polkadot_api::ErrorKind::Executor(_)) => Ok(false),
@@ -656,6 +656,7 @@ fn evaluate_proposal<C: PolkadotApi>(
  client: &C,
  now: Timestamp,
  parent_hash: &HeaderHash,
+ parent_number: BlockNumber,
  parent_id: &C::CheckedBlockId,
 ) -> Result<bool, Error> {
  const MAX_TIMESTAMP_DRIFT: Timestamp = 4;
@@ -677,9 +678,9 @@ fn evaluate_proposal<C: PolkadotApi>(
  bail!(ErrorKind::WrongParentHash(*parent_hash, proposal.header.parent_hash));
  }
 
- // no need to check number because
- // a) we assume the parent is valid.
- // b) the runtime checks that `proposal.parent_hash` == `block_hash(proposal.number - 1)`
+ if proposal.header.number != parent_number + 1 {
+  bail!(ErrorKind::WrongNumber(parent_number + 1, proposal.header.number))
+ }
 
  let block_timestamp = proposal.timestamp();
 

polkadot/consensus/src/service.rs

@@ -249,12 +249,13 @@ fn start_bft<F, C>(
  return;
  }
  };
+
  let input = messages.select(hash, network.bft_messages(), authorities).map_err(|e| e.into());
  let output = BftSink { network: network, parent_hash: hash.clone(), _e: Default::default() };
  match bft_service.build_upon(&header, input, output) {
  Ok(Some(bft)) => handle.spawn(bft),
  Ok(None) => {},
- Err(e) => debug!("BFT agreement error: {:?}", e),
+ Err(e) => debug!(target: "bft","BFT agreement error: {:?}", e),
  }
 }
 

polkadot/service/src/lib.rs

@@ -258,11 +258,6 @@ impl Service {
  let prepare_genesis = || {
  storage = genesis_config.build_externalities();
  let block = genesis::construct_genesis_block(&storage);
- with_externalities(&mut storage, || {
- // TODO: use api.rs to dispatch instead
- polkadot_runtime::System::initialise_genesis_state(&block.header);
- info!("Genesis header hash: {}", polkadot_runtime::System::block_hash(0));
- });
  (primitives::block::Header::decode(&mut block.header.encode().as_ref()).expect("to_vec() always gives a valid serialisation; qed"), storage.into_iter().collect())
  };
 

substrate/runtime/executive/src/lib.rs

@@ -104,9 +104,6 @@ impl<
 
  // any final checks
  Self::final_checks(&header);
-
- // any stuff that we do after taking the storage root.
- Self::post_finalise(&header);
  }
 
  /// Finalise the block - it is up the caller to ensure that all header fields are valid
@@ -116,11 +113,7 @@ impl<
 
  // setup extrinsics
  <system::Module<System>>::derive_extrinsics();
-
- let header = <system::Module<System>>::finalise();
- Self::post_finalise(&header);
-
- header
+ <system::Module<System>>::finalise()
  }
 
  /// Apply outside of the block execution function.
@@ -170,12 +163,6 @@ impl<
  header.state_root().check_equal(&storage_root);
  assert!(header.state_root() == &storage_root, "Storage root must match that calculated.");
  }
-
- fn post_finalise(header: &System::Header) {
- // store the header hash in storage; we can't do it before otherwise there would be a
- // cyclic dependency.
- <system::Module<System>>::record_block_hash(header);
- }
 }
 
 #[cfg(test)]

substrate/runtime/system/src/lib.rs

@@ -94,6 +94,7 @@ impl<T: Trait> Module<T> {
  // populate environment.
  <Number<T>>::put(number);
  <ParentHash<T>>::put(parent_hash);
+ <BlockHash<T>>::insert(*number - One::one(), parent_hash);
  <ExtrinsicsRoot<T>>::put(txs_root);
  <RandomSeed<T>>::put(Self::calculate_random());
  <ExtrinsicIndex<T>>::put(0);
@@ -119,21 +120,6 @@ impl<T: Trait> Module<T> {
  <Digest<T>>::put(l);
  }
 
- /// Records a particular block number and hash combination.
- pub fn record_block_hash<H: traits::Header<Number = T::BlockNumber, Hash = T::Hash>>(header: &H) {
- // store the header hash in storage; we can't do it before otherwise there would be a
- // cyclic dependency.
- let h = T::Hashing::hash_of(header);
- <BlockHash<T>>::insert(header.number(), &h);
-
- Self::initialise(&(*header.number() + One::one()), &h, &Default::default());
- }
-
- /// Initializes the state following the determination of the genesis block.
- pub fn initialise_genesis_state<H: traits::Header<Number = T::BlockNumber, Hash = T::Hash>>(header: &H) {
- Self::record_block_hash(header);
- }
-
  /// Calculate the current block's random seed.
  fn calculate_random() -> T::Hash {
  assert!(Self::block_number() > Zero::zero(), "Block number may never be zero");