Add chain RPCs and getHeader.

demo/cli/src/lib.rs

@@ -130,7 +130,7 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
  let client = Arc::new(client::new_in_mem(executor, prepare_genesis)?);
 
  let address = "127.0.0.1:9933".parse().unwrap();
- let handler = rpc::rpc_handler(client, DummyPool);
+ let handler = rpc::rpc_handler(client, DummyPool, client);
  let server = rpc::start_http(&address, handler)?;
 
  if let Some(_) = matches.subcommand_matches("validator") {

polkadot/cli/src/lib.rs

@@ -141,7 +141,7 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
  address.set_port(rpc_port);
  }
 
- let handler = rpc::rpc_handler(service.client(), service.transaction_pool());
+ let handler = rpc::rpc_handler(service.client(), service.transaction_pool(), service.client());
  let _server = rpc::start_http(&address, handler)?;
 
  informant::start(&service, core.handle());

polkadot/service/src/lib.rs

@@ -123,7 +123,12 @@ impl network::TransactionPool for TransactionPoolAdapter {
  }
 }
 
-fn poc_1_testnet_config() -> GenesisConfig {
+pub struct ChainConfig {
+ genesis_config: GenesisConfig,
+ boot_nodes: Vec<String>,
+}
+
+fn poc_1_testnet_config() -> ChainConfig {
  let initial_authorities = vec![
  hex!["82c39b31a2b79a90f8e66e7a77fdb85a4ed5517f2ae39f6a80565e8ecae85cf5"].into(),
  hex!["4de37a07567ebcbf8c64568428a835269a566723687058e017b6d69db00a77e7"].into(),
@@ -132,7 +137,7 @@ fn poc_1_testnet_config() -> GenesisConfig {
  let endowed_accounts = vec![
  hex!["24d132eb1a4cbf8e46de22652019f1e07fadd5037a6a057c75dbbfd4641ba85d"].into(),
  ];
- GenesisConfig {
+ let genesis_config = GenesisConfig {
  consensus: Some(ConsensusConfig {
  code: include_bytes!("../../runtime/wasm/genesis.wasm").to_vec(), // TODO change
  authorities: initial_authorities.clone(),
@@ -173,10 +178,12 @@ fn poc_1_testnet_config() -> GenesisConfig {
  voting_period: 7 * 120 * 24, // 7 day voting period for council members.
  }),
  parachains: Some(Default::default()),
- }
+ };
+ let boot_nodes = Vec::new();
+ ChainConfig { genesis_config, boot_nodes }
 }
 
-fn local_testnet_config() -> GenesisConfig {
+fn local_testnet_config() -> ChainConfig {
  let initial_authorities = vec![
  ed25519::Pair::from_seed(b"Alice ").public().into(),
  ed25519::Pair::from_seed(b"Bob ").public().into(),
@@ -189,7 +196,7 @@ fn local_testnet_config() -> GenesisConfig {
  ed25519::Pair::from_seed(b"Eve ").public().into(),
  ed25519::Pair::from_seed(b"Ferdie ").public().into(),
  ];
- GenesisConfig {
+ let genesis_config = GenesisConfig {
  consensus: Some(ConsensusConfig {
  code: include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/polkadot_runtime.compact.wasm").to_vec(),
  authorities: initial_authorities.clone(),
@@ -198,44 +205,46 @@ fn local_testnet_config() -> GenesisConfig {
 // block_time: 5, // 5 second block time.
  session: Some(SessionConfig {
  validators: initial_authorities.clone(),
- session_length: 720, // that's 1 hour per session.
+ session_length: 10,
  }),
  staking: Some(StakingConfig {
  current_era: 0,
  intentions: vec![],
- transaction_fee: 100,
+ transaction_fee: 1,
  balances: endowed_accounts.iter().map(|&k|(k, 1u64 << 60)).collect(),
- validator_count: 12,
- sessions_per_era: 24, // 24 hours per era.
- bonding_duration: 90, // 90 days per bond.
+ validator_count: 2,
+ sessions_per_era: 5, // 24 hours per era.
+ bonding_duration: 2, // 90 days per bond.
  }),
  democracy: Some(DemocracyConfig {
- launch_period: 120 * 24 * 14, // 2 weeks per public referendum
- voting_period: 120 * 24 * 28, // 4 weeks to discuss & vote on an active referendum
- minimum_deposit: 1000, // 1000 as the minimum deposit for a referendum
+ launch_period: 9, // 2 weeks per public referendum
+ voting_period: 18, // 4 weeks to discuss & vote on an active referendum
+ minimum_deposit: 10, // 1000 as the minimum deposit for a referendum
  }),
  council: Some(CouncilConfig {
  active_council: vec![],
- candidacy_bond: 1000, // 1000 to become a council candidate
- voter_bond: 100, // 100 down to vote for a candidate
+ candidacy_bond: 10, // 1000 to become a council candidate
+ voter_bond: 2, // 100 down to vote for a candidate
  present_slash_per_voter: 1, // slash by 1 per voter for an invalid presentation.
- carry_count: 24, // carry over the 24 runners-up to the next council election
- presentation_duration: 120 * 24, // one day for presenting winners.
- approval_voting_period: 7 * 120 * 24, // one week period between possible council elections.
- term_duration: 180 * 120 * 24, // 180 day term duration for the council.
+ carry_count: 4, // carry over the 24 runners-up to the next council election
+ presentation_duration: 10, // one day for presenting winners.
+ approval_voting_period: 20, // one week period between possible council elections.
+ term_duration: 40, // 180 day term duration for the council.
  desired_seats: 0, // start with no council: we'll raise this once the stake has been dispersed a bit.
  inactive_grace_period: 1, // one addition vote should go by before an inactive voter can be reaped.
 
- cooloff_period: 90 * 120 * 24, // 90 day cooling off period if council member vetoes a proposal.
- voting_period: 7 * 120 * 24, // 7 day voting period for council members.
+ cooloff_period: 75, // 90 day cooling off period if council member vetoes a proposal.
+ voting_period: 20, // 7 day voting period for council members.
  }),
  parachains: Some(Default::default()),
- }
+ };
+ let boot_nodes = Vec::new();
+ ChainConfig { genesis_config, boot_nodes }
 }
 
 impl Service {
  /// Creates and register protocol with the network service
- pub fn new(config: Configuration) -> Result<Service, error::Error> {
+ pub fn new(mut config: Configuration) -> Result<Service, error::Error> {
  // Create client
  let executor = polkadot_executor::Executor::new();
  let mut storage = Default::default();
@@ -250,10 +259,11 @@ impl Service {
  info!("Generated a new keypair: {:?}", key.public());
  }
 
- let genesis_config = match config.chain_spec {
+ let ChainConfig { genesis_config, boot_nodes } = match config.chain_spec {
  ChainSpec::Development => local_testnet_config(),
  ChainSpec::PoC1Testnet => poc_1_testnet_config(),
  };
+ config.network.boot_nodes.extend(boot_nodes);
 
  let prepare_genesis = || {
  storage = genesis_config.build_externalities();

substrate/client/src/block_builder.rs

@@ -55,7 +55,7 @@ impl<B, E> BlockBuilder<B, E> where
  number: client.block_number_from_id(block_id)?.ok_or(error::ErrorKind::UnknownBlock(*block_id))? + 1,
  parent_hash: client.block_hash_from_id(block_id)?.ok_or(error::ErrorKind::UnknownBlock(*block_id))?,
  state_root: Default::default(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  },
  transactions: Default::default(),
@@ -78,7 +78,7 @@ impl<B, E> BlockBuilder<B, E> where
 
  /// Consume the builder to return a valid `Block` containing all pushed transactions.
  pub fn bake(mut self) -> error::Result<Block> {
- self.header.transaction_root = ordered_trie_root(self.transactions.iter().map(Slicable::encode)).0.into();
+ self.header.extrinsics_root = ordered_trie_root(self.transactions.iter().map(Slicable::encode)).0.into();
  let output = state_machine::execute(&self.state, &mut self.changes, &self.executor, "finalise_block",
  &self.header.encode())?;
  self.header = Header::decode(&mut &output[..]).expect("Header came straight out of runtime so must be valid");

substrate/client/src/genesis.rs

@@ -27,7 +27,7 @@ pub fn construct_genesis_block(storage: &HashMap<Vec<u8>, Vec<u8>>) -> Block {
  parent_hash: Default::default(),
  number: 0,
  state_root,
- transaction_root: trie_root(vec![].into_iter()).0.into(),
+ extrinsics_root: trie_root(vec![].into_iter()).0.into(),
  digest: Default::default(),
  };
  Block {
@@ -62,13 +62,13 @@ mod tests {
  UncheckedTransaction { tx, signature }
  }).collect::<Vec<_>>();
 
- let transaction_root = ordered_trie_root(transactions.iter().map(Slicable::encode)).0.into();
+ let extrinsics_root = ordered_trie_root(transactions.iter().map(Slicable::encode)).0.into();
 
  let mut header = Header {
  parent_hash,
  number,
  state_root,
- transaction_root,
+ extrinsics_root,
  digest: Digest { logs: vec![], },
  };
  let hash = header.blake2_256();

substrate/primitives/src/block.rs

@@ -146,7 +146,7 @@ pub struct Header {
  /// State root after this transition.
  pub state_root: Hash,
  /// The root of the trie that represents this block's transactions, indexed by a 32-byte integer.
- pub transaction_root: Hash,
+ pub extrinsics_root: Hash,
  // TODO...
 // /// The root of the trie that represents the receipts from this block's transactions
 // pub receipts_root: Hash,
@@ -161,7 +161,7 @@ impl Header {
  parent_hash: Default::default(),
  number,
  state_root: Default::default(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  }
  }
@@ -173,7 +173,7 @@ impl Slicable for Header {
  parent_hash: Slicable::decode(input)?,
  number: Slicable::decode(input)?,
  state_root: Slicable::decode(input)?,
- transaction_root: Slicable::decode(input)?,
+ extrinsics_root: Slicable::decode(input)?,
  digest: Slicable::decode(input)?,
  })
  }
@@ -184,7 +184,7 @@ impl Slicable for Header {
  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.extrinsics_root.using_encoded(|s| v.extend(s));
  self.digest.using_encoded(|s| v.extend(s));
 
  v
@@ -222,7 +222,7 @@ mod tests {
  parent_hash: 5.into(),
  number: 67,
  state_root: 3.into(),
- transaction_root: 6.into(),
+ extrinsics_root: 6.into(),
  digest: Digest { logs: vec![Log(vec![1]), Log(vec![2])] },
  };
 
@@ -233,7 +233,7 @@ mod tests {
  67, 0, 0, 0, 0, 0, 0, 0,
  // state_root
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
- // transaction_root
+ // extrinsics_root
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,
  // digest (length, log1, log2)
  2, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 2
@@ -246,15 +246,15 @@ mod tests {
  parent_hash: 5.into(),
  number: 67,
  state_root: 3.into(),
- transaction_root: 6.into(),
+ extrinsics_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",
+ "extrinsicsRoot": "0x0000000000000000000000000000000000000000000000000000000000000006",
  "digest": {
  "logs": [
  "0x01"
@@ -280,7 +280,7 @@ mod tests {
  12, 0, 0, 0, 0, 0, 0, 0,
  // state_root
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- // transaction_root
+ // extrinsics_root
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  // digest
  0, 0, 0, 0,

substrate/rpc-servers/src/lib.rs

@@ -26,13 +26,15 @@ extern crate jsonrpc_http_server as http;
 use std::io;
 
 /// Construct rpc `IoHandler`
-pub fn rpc_handler<S, T>(state: S, transaction_pool: T) -> rpc::IoHandler where
+pub fn rpc_handler<S, T, C>(state: S, transaction_pool: T, chain: C) -> rpc::IoHandler where
  S: apis::state::StateApi,
  T: apis::author::AuthorApi,
+ C: apis::chain::ChainApi,
 {
  let mut io = rpc::IoHandler::new();
  io.extend_with(state.to_delegate());
  io.extend_with(transaction_pool.to_delegate());
+ io.extend_with(chain.to_delegate());
  io
 }
 

substrate/rpc/src/chain/mod.rs

@@ -16,8 +16,9 @@
 
 //! Substrate blockchain API.
 
+use std::sync::Arc;
 use primitives::block;
-use client;
+use client::{self, Client};
 use state_machine;
 
 mod error;
@@ -33,15 +34,23 @@ build_rpc_trait! {
  /// Get header of a relay chain block.
  #[rpc(name = "chain_getHeader")]
  fn header(&self, block::HeaderHash) -> Result<Option<block::Header>>;
+
+ /// Get hash of the head.
+ #[rpc(name = "chain_getHead")]
+ fn head(&self) -> Result<block::HeaderHash>;
  }
 }
 
-impl<B, E> ChainApi for client::Client<B, E> where
+impl<B, E> ChainApi for Arc<Client<B, E>> where
  B: client::backend::Backend + Send + Sync + 'static,
  E: state_machine::CodeExecutor + Send + Sync + 'static,
  client::error::Error: From<<<B as client::backend::Backend>::State as state_machine::backend::Backend>::Error>,
 {
  fn header(&self, hash: block::HeaderHash) -> Result<Option<block::Header>> {
  client::Client::header(self, &block::Id::Hash(hash)).chain_err(|| "Blockchain error")
  }
+
+ fn head(&self) -> Result<block::HeaderHash> {
+ Ok(client::Client::info(self).chain_err(|| "Blockchain error")?.chain.best_hash)
+ }
 }

substrate/rpc/src/chain/tests.rs

@@ -25,7 +25,7 @@ fn should_return_header() {
  parent_hash: 0.into(),
  number: 0,
  state_root: 0.into(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  };
 
@@ -37,7 +37,7 @@ fn should_return_header() {
  parent_hash: 0.into(),
  number: 0,
  state_root: 0.into(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  }
  );

substrate/rpc/src/state/tests.rs

@@ -26,7 +26,7 @@ fn should_return_storage() {
  parent_hash: 0.into(),
  number: 0,
  state_root: 0.into(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  };
 
@@ -47,7 +47,7 @@ fn should_call_contract() {
  parent_hash: 0.into(),
  number: 0,
  state_root: 0.into(),
- transaction_root: Default::default(),
+ extrinsics_root: Default::default(),
  digest: Default::default(),
  };
 

substrate/runtime/primitives/src/traits.rs

@@ -189,7 +189,7 @@ impl Header for substrate_primitives::Header {
  type Hash = substrate_primitives::block::HeaderHash;
  type Digest = substrate_primitives::block::Digest;
  fn number(&self) -> &Self::Number { &self.number }
- fn extrinsics_root(&self) -> &Self::Hash { &self.transaction_root }
+ fn extrinsics_root(&self) -> &Self::Hash { &self.extrinsics_root }
  fn state_root(&self) -> &Self::Hash { &self.state_root }
  fn parent_hash(&self) -> &Self::Hash { &self.parent_hash }
  fn digest(&self) -> &Self::Digest { &self.digest }
@@ -202,7 +202,7 @@ impl Header for substrate_primitives::Header {
  ) -> Self {
  substrate_primitives::Header {
  number: number,
- transaction_root: extrinsics_root,
+ extrinsics_root: extrinsics_root,
  state_root: state_root,
  parent_hash: parent_hash,
  digest: digest,