Fixes to prev Authority PR

core/beacon/src/authority.rs

@@ -124,14 +124,13 @@ impl Authority {
                 }
             }
         }
-        // assert_eq!(dup_proposals.len(), num_seats);
+        assert_eq!(dup_proposals.len(), num_seats as usize);
         for i in 0..self.authority_config.epoch_length {
-            //            let start: usize = (i * self.authority_config.num_seats_per_slot).into();
-            //            let authorities = dup_proposals[usize::from(i * self.authority_config.num_seats_per_slot)..usize::from((i + 1) * self.authority_config.num_seats_per_slot)];
-            let authorities = dup_proposals.clone();
+            let start = (i * self.authority_config.num_seats_per_slot) as usize;
+            let end = ((i + 1) * self.authority_config.num_seats_per_slot) as usize;
             result.insert(
                 self.current_epoch * self.authority_config.epoch_length + i + 1,
-                authorities,
+                dup_proposals[start..end].to_vec(),
             );
         }
         result
@@ -195,16 +194,16 @@ mod test {
 
     #[test]
     fn test_authority_genesis() {
-        let authority_config = get_test_config(5, 2, 2);
+        let authority_config = get_test_config(4, 2, 2);
         let initial_authorities: Vec<PublicKey> =
             authority_config.initial_authorities.iter().map(|a| a.public_key).collect();
         let bc = test_blockchain(0);
         let mut authority = Authority::new(authority_config, &bc);
         assert_eq!(authority.get_authorities(0).unwrap(), vec![]);
-        assert_eq!(authority.get_authorities(1).unwrap(), initial_authorities);
-        assert_eq!(authority.get_authorities(2).unwrap(), initial_authorities);
-        assert_eq!(authority.get_authorities(3).unwrap(), initial_authorities);
-        assert_eq!(authority.get_authorities(4).unwrap(), initial_authorities);
+        assert_eq!(authority.get_authorities(1).unwrap(), initial_authorities[0..2].to_vec());
+        assert_eq!(authority.get_authorities(2).unwrap(), initial_authorities[2..4].to_vec());
+        assert_eq!(authority.get_authorities(3).unwrap(), initial_authorities[0..2].to_vec());
+        assert_eq!(authority.get_authorities(4).unwrap(), initial_authorities[2..4].to_vec());
         assert!(authority.get_authorities(5).is_err());
         let header = BeaconBlockHeader::new(
             1,

core/beacon/src/types.rs

@@ -12,17 +12,6 @@ pub struct AuthorityProposal {
     pub amount: u64,
 }
 
-//pub struct BeaconBlockBody {
-//    /// Parent hash.
-//    pub parent_hash: CryptoHash,
-//    /// Block index.
-//    pub index: u64,
-//    /// Authority proposals.
-//    pub authority_proposal: Vec<AuthorityProposal>,
-//    /// Shard block hash.
-//    pub shard_block_hash: CryptoHash,
-//}
-
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct BeaconBlockHeaderBody {
     /// Parent hash.
@@ -31,6 +20,7 @@ pub struct BeaconBlockHeaderBody {
     pub index: u64,
     pub merkle_root_tx: MerkleHash,
     pub merkle_root_state: MerkleHash,
+    /// Authority proposals.
     pub authority_proposal: Vec<AuthorityProposal>,
 }
 
@@ -80,8 +70,8 @@ impl BeaconBlockHeader {
 
 impl Header for BeaconBlockHeader {
     fn hash(&self) -> CryptoHash {
-        // WTF?
-        hash_struct(&self)
+        // TODO: must be hash of the block.
+        hash_struct(&self.body)
     }
 
     fn index(&self) -> u64 {

core/primitives/src/types.rs

@@ -10,7 +10,7 @@ pub type UID = u64;
 /// Account alias. Can be an easily identifiable string, when hashed creates the AccountId.
 pub type AccountAlias = String;
 /// Public key alias. Used to human readable public key.
-pub type PublicKeyAlias = String;
+pub type ReadablePublicKey = String;
 /// Account identifier. Provides access to user's state.
 pub type AccountId = CryptoHash;
 // TODO: Separate cryptographic hash from the hashmap hash.
@@ -30,8 +30,8 @@ impl<'a> From<&'a AccountAlias> for AccountId {
     }
 }
 
-impl<'a> From<&'a PublicKeyAlias> for PublicKey {
-    fn from(alias: &PublicKeyAlias) -> Self {
+impl<'a> From<&'a ReadablePublicKey> for PublicKey {
+    fn from(alias: &ReadablePublicKey) -> Self {
         PublicKey::from(alias)
     }
 }

node/cli/src/chain_spec.rs

@@ -1,12 +1,13 @@
-use primitives::types::{AccountAlias, PublicKeyAlias};
 use serde_json;
+
 use node_runtime::chain_spec::ChainSpec;
+use primitives::types::{AccountAlias, ReadablePublicKey};
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "ChainSpec")]
 struct ChainSpecRef {
-    accounts: Vec<(AccountAlias, PublicKeyAlias, u64)>,
-    initial_authorities: Vec<(PublicKeyAlias, u64)>,
+    accounts: Vec<(AccountAlias, ReadablePublicKey, u64)>,
+    initial_authorities: Vec<(ReadablePublicKey, u64)>,
     genesis_wasm: Vec<u8>,
     beacon_chain_epoch_length: u64,
     beacon_chain_num_seats_per_slot: u64,

node/cli2/src/chain_spec.rs

@@ -2,15 +2,16 @@ use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
-use node_runtime::chain_spec::ChainSpec;
-use primitives::types::{AccountAlias, PublicKeyAlias};
 use serde_json;
 
+use node_runtime::chain_spec::ChainSpec;
+use primitives::types::{AccountAlias, ReadablePublicKey};
+
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "ChainSpec")]
 struct ChainSpecRef {
-    accounts: Vec<(AccountAlias, PublicKeyAlias, u64)>,
-    initial_authorities: Vec<(PublicKeyAlias, u64)>,
+    accounts: Vec<(AccountAlias, ReadablePublicKey, u64)>,
+    initial_authorities: Vec<(ReadablePublicKey, u64)>,
     genesis_wasm: Vec<u8>,
     beacon_chain_epoch_length: u64,
     beacon_chain_num_seats_per_slot: u64,

node/runtime/src/chain_spec.rs

@@ -1,15 +1,15 @@
-use primitives::types::{AccountAlias, PublicKeyAlias};
+use primitives::types::{AccountAlias, ReadablePublicKey};
 
 /// Specification of the blockchain in general.
 pub struct ChainSpec {
     /// Genesis state accounts.
-    pub accounts: Vec<(AccountAlias, PublicKeyAlias, u64)>,
+    pub accounts: Vec<(AccountAlias, ReadablePublicKey, u64)>,
 
     /// Genesis smart contract code.
     pub genesis_wasm: Vec<u8>,
 
     /// Genesis state authorities that bootstrap the chain.
-    pub initial_authorities: Vec<(PublicKeyAlias, u64)>,
+    pub initial_authorities: Vec<(ReadablePublicKey, u64)>,
 
     pub beacon_chain_epoch_length: u64,
     pub beacon_chain_num_seats_per_slot: u64,

node/runtime/src/lib.rs

@@ -23,7 +23,7 @@ use primitives::hash::CryptoHash;
 use primitives::signature::PublicKey;
 use primitives::traits::{Decode, Encode};
 use primitives::types::{
-    AccountAlias, AccountId, MerkleHash, PublicKeyAlias, SignedTransaction, ViewCall,
+    AccountAlias, AccountId, MerkleHash, ReadablePublicKey, SignedTransaction, ViewCall,
     ViewCallResult, PromiseId,
 };
 use primitives::utils::concat;
@@ -323,7 +323,7 @@ impl Runtime {
 
     pub fn apply_genesis_state(
         &self,
-        balances: &[(AccountAlias, PublicKeyAlias, u64)],
+        balances: &[(AccountAlias, ReadablePublicKey, u64)],
         wasm_binary: &[u8],
     ) -> MerkleHash {
         let mut state_db_update =