Merge pull request #238 from mjkeating/tree_hash_add_padding2

Updated TreeHash to spec - added padding

eth2/types/src/attestation.rs

@@ -60,12 +60,12 @@ impl Decodable for Attestation {
 }
 
 impl TreeHash for Attestation {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.aggregation_bitfield.hash_tree_root());
-        result.append(&mut self.data.hash_tree_root());
-        result.append(&mut self.custody_bitfield.hash_tree_root());
-        result.append(&mut self.aggregate_signature.hash_tree_root());
+        result.append(&mut self.aggregation_bitfield.hash_tree_root_internal());
+        result.append(&mut self.data.hash_tree_root_internal());
+        result.append(&mut self.custody_bitfield.hash_tree_root_internal());
+        result.append(&mut self.aggregate_signature.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -99,11 +99,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Attestation::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/attestation_data.rs

@@ -82,16 +82,16 @@ impl Decodable for AttestationData {
 }
 
 impl TreeHash for AttestationData {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.shard.hash_tree_root());
-        result.append(&mut self.beacon_block_root.hash_tree_root());
-        result.append(&mut self.epoch_boundary_root.hash_tree_root());
-        result.append(&mut self.shard_block_root.hash_tree_root());
-        result.append(&mut self.latest_crosslink.hash_tree_root());
-        result.append(&mut self.justified_epoch.hash_tree_root());
-        result.append(&mut self.justified_block_root.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root_internal());
+        result.append(&mut self.shard.hash_tree_root_internal());
+        result.append(&mut self.beacon_block_root.hash_tree_root_internal());
+        result.append(&mut self.epoch_boundary_root.hash_tree_root_internal());
+        result.append(&mut self.shard_block_root.hash_tree_root_internal());
+        result.append(&mut self.latest_crosslink.hash_tree_root_internal());
+        result.append(&mut self.justified_epoch.hash_tree_root_internal());
+        result.append(&mut self.justified_block_root.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -129,11 +129,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = AttestationData::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -29,11 +29,11 @@ impl Decodable for AttestationDataAndCustodyBit {
 }
 
 impl TreeHash for AttestationDataAndCustodyBit {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.data.hash_tree_root());
+        result.append(&mut self.data.hash_tree_root_internal());
         // TODO: add bool ssz
-        // result.append(custody_bit.hash_tree_root());
+        // result.append(custody_bit.hash_tree_root_internal());
         ssz::hash(&result)
     }
 }
@@ -68,11 +68,11 @@ mod test {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = AttestationDataAndCustodyBit::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/attester_slashing.rs

@@ -32,10 +32,10 @@ impl Decodable for AttesterSlashing {
 }
 
 impl TreeHash for AttesterSlashing {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slashable_attestation_1.hash_tree_root());
-        result.append(&mut self.slashable_attestation_2.hash_tree_root());
+        result.append(&mut self.slashable_attestation_1.hash_tree_root_internal());
+        result.append(&mut self.slashable_attestation_2.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -67,11 +67,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = AttesterSlashing::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/beacon_block.rs

@@ -97,15 +97,15 @@ impl Decodable for BeaconBlock {
 }
 
 impl TreeHash for BeaconBlock {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.parent_root.hash_tree_root());
-        result.append(&mut self.state_root.hash_tree_root());
-        result.append(&mut self.randao_reveal.hash_tree_root());
-        result.append(&mut self.eth1_data.hash_tree_root());
-        result.append(&mut self.signature.hash_tree_root());
-        result.append(&mut self.body.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root_internal());
+        result.append(&mut self.parent_root.hash_tree_root_internal());
+        result.append(&mut self.state_root.hash_tree_root_internal());
+        result.append(&mut self.randao_reveal.hash_tree_root_internal());
+        result.append(&mut self.eth1_data.hash_tree_root_internal());
+        result.append(&mut self.signature.hash_tree_root_internal());
+        result.append(&mut self.body.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -142,11 +142,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = BeaconBlock::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/beacon_block_body.rs

@@ -45,13 +45,13 @@ impl Decodable for BeaconBlockBody {
 }
 
 impl TreeHash for BeaconBlockBody {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.proposer_slashings.hash_tree_root());
-        result.append(&mut self.attester_slashings.hash_tree_root());
-        result.append(&mut self.attestations.hash_tree_root());
-        result.append(&mut self.deposits.hash_tree_root());
-        result.append(&mut self.exits.hash_tree_root());
+        result.append(&mut self.proposer_slashings.hash_tree_root_internal());
+        result.append(&mut self.attester_slashings.hash_tree_root_internal());
+        result.append(&mut self.attestations.hash_tree_root_internal());
+        result.append(&mut self.deposits.hash_tree_root_internal());
+        result.append(&mut self.exits.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -86,11 +86,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = BeaconBlockBody::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/beacon_state.rs

@@ -1059,33 +1059,37 @@ impl Decodable for BeaconState {
 }
 
 impl TreeHash for BeaconState {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.genesis_time.hash_tree_root());
-        result.append(&mut self.fork.hash_tree_root());
-        result.append(&mut self.validator_registry.hash_tree_root());
-        result.append(&mut self.validator_balances.hash_tree_root());
-        result.append(&mut self.validator_registry_update_epoch.hash_tree_root());
-        result.append(&mut self.latest_randao_mixes.hash_tree_root());
-        result.append(&mut self.previous_epoch_start_shard.hash_tree_root());
-        result.append(&mut self.current_epoch_start_shard.hash_tree_root());
-        result.append(&mut self.previous_calculation_epoch.hash_tree_root());
-        result.append(&mut self.current_calculation_epoch.hash_tree_root());
-        result.append(&mut self.previous_epoch_seed.hash_tree_root());
-        result.append(&mut self.current_epoch_seed.hash_tree_root());
-        result.append(&mut self.previous_justified_epoch.hash_tree_root());
-        result.append(&mut self.justified_epoch.hash_tree_root());
-        result.append(&mut self.justification_bitfield.hash_tree_root());
-        result.append(&mut self.finalized_epoch.hash_tree_root());
-        result.append(&mut self.latest_crosslinks.hash_tree_root());
-        result.append(&mut self.latest_block_roots.hash_tree_root());
-        result.append(&mut self.latest_index_roots.hash_tree_root());
-        result.append(&mut self.latest_penalized_balances.hash_tree_root());
-        result.append(&mut self.latest_attestations.hash_tree_root());
-        result.append(&mut self.batched_block_roots.hash_tree_root());
-        result.append(&mut self.latest_eth1_data.hash_tree_root());
-        result.append(&mut self.eth1_data_votes.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root_internal());
+        result.append(&mut self.genesis_time.hash_tree_root_internal());
+        result.append(&mut self.fork.hash_tree_root_internal());
+        result.append(&mut self.validator_registry.hash_tree_root_internal());
+        result.append(&mut self.validator_balances.hash_tree_root_internal());
+        result.append(
+            &mut self
+                .validator_registry_update_epoch
+                .hash_tree_root_internal(),
+        );
+        result.append(&mut self.latest_randao_mixes.hash_tree_root_internal());
+        result.append(&mut self.previous_epoch_start_shard.hash_tree_root_internal());
+        result.append(&mut self.current_epoch_start_shard.hash_tree_root_internal());
+        result.append(&mut self.previous_calculation_epoch.hash_tree_root_internal());
+        result.append(&mut self.current_calculation_epoch.hash_tree_root_internal());
+        result.append(&mut self.previous_epoch_seed.hash_tree_root_internal());
+        result.append(&mut self.current_epoch_seed.hash_tree_root_internal());
+        result.append(&mut self.previous_justified_epoch.hash_tree_root_internal());
+        result.append(&mut self.justified_epoch.hash_tree_root_internal());
+        result.append(&mut self.justification_bitfield.hash_tree_root_internal());
+        result.append(&mut self.finalized_epoch.hash_tree_root_internal());
+        result.append(&mut self.latest_crosslinks.hash_tree_root_internal());
+        result.append(&mut self.latest_block_roots.hash_tree_root_internal());
+        result.append(&mut self.latest_index_roots.hash_tree_root_internal());
+        result.append(&mut self.latest_penalized_balances.hash_tree_root_internal());
+        result.append(&mut self.latest_attestations.hash_tree_root_internal());
+        result.append(&mut self.batched_block_roots.hash_tree_root_internal());
+        result.append(&mut self.latest_eth1_data.hash_tree_root_internal());
+        result.append(&mut self.eth1_data_votes.hash_tree_root_internal());
         hash(&result)
     }
 }

eth2/types/src/beacon_state/tests.rs

@@ -85,11 +85,11 @@ pub fn test_ssz_round_trip() {
 }
 
 #[test]
-pub fn test_hash_tree_root() {
+pub fn test_hash_tree_root_internal() {
     let mut rng = XorShiftRng::from_seed([42; 16]);
     let original = BeaconState::random_for_test(&mut rng);
 
-    let result = original.hash_tree_root();
+    let result = original.hash_tree_root_internal();
 
     assert_eq!(result.len(), 32);
     // TODO: Add further tests

eth2/types/src/casper_slashing.rs

@@ -33,10 +33,10 @@ impl Decodable for CasperSlashing {
 }
 
 impl TreeHash for CasperSlashing {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slashable_vote_data_1.hash_tree_root());
-        result.append(&mut self.slashable_vote_data_2.hash_tree_root());
+        result.append(&mut self.slashable_vote_data_1.hash_tree_root_internal());
+        result.append(&mut self.slashable_vote_data_2.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -68,11 +68,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = CasperSlashing::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/crosslink.rs

@@ -43,10 +43,10 @@ impl Decodable for Crosslink {
 }
 
 impl TreeHash for Crosslink {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.epoch.hash_tree_root());
-        result.append(&mut self.shard_block_root.hash_tree_root());
+        result.append(&mut self.epoch.hash_tree_root_internal());
+        result.append(&mut self.shard_block_root.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -78,11 +78,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Crosslink::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/deposit.rs

@@ -37,11 +37,11 @@ impl Decodable for Deposit {
 }
 
 impl TreeHash for Deposit {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.branch.hash_tree_root());
-        result.append(&mut self.index.hash_tree_root());
-        result.append(&mut self.deposit_data.hash_tree_root());
+        result.append(&mut self.branch.hash_tree_root_internal());
+        result.append(&mut self.index.hash_tree_root_internal());
+        result.append(&mut self.deposit_data.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -74,11 +74,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Deposit::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/deposit_data.rs

@@ -37,11 +37,11 @@ impl Decodable for DepositData {
 }
 
 impl TreeHash for DepositData {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.amount.hash_tree_root());
-        result.append(&mut self.timestamp.hash_tree_root());
-        result.append(&mut self.deposit_input.hash_tree_root());
+        result.append(&mut self.amount.hash_tree_root_internal());
+        result.append(&mut self.timestamp.hash_tree_root_internal());
+        result.append(&mut self.deposit_input.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -74,11 +74,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = DepositData::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/deposit_input.rs

@@ -38,11 +38,11 @@ impl Decodable for DepositInput {
 }
 
 impl TreeHash for DepositInput {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.pubkey.hash_tree_root());
-        result.append(&mut self.withdrawal_credentials.hash_tree_root());
-        result.append(&mut self.proof_of_possession.hash_tree_root());
+        result.append(&mut self.pubkey.hash_tree_root_internal());
+        result.append(&mut self.withdrawal_credentials.hash_tree_root_internal());
+        result.append(&mut self.proof_of_possession.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -75,11 +75,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = DepositInput::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/eth1_data.rs

@@ -34,10 +34,10 @@ impl Decodable for Eth1Data {
 }
 
 impl TreeHash for Eth1Data {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.deposit_root.hash_tree_root());
-        result.append(&mut self.block_hash.hash_tree_root());
+        result.append(&mut self.deposit_root.hash_tree_root_internal());
+        result.append(&mut self.block_hash.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -69,11 +69,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Eth1Data::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/eth1_data_vote.rs

@@ -34,10 +34,10 @@ impl Decodable for Eth1DataVote {
 }
 
 impl TreeHash for Eth1DataVote {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.eth1_data.hash_tree_root());
-        result.append(&mut self.vote_count.hash_tree_root());
+        result.append(&mut self.eth1_data.hash_tree_root_internal());
+        result.append(&mut self.vote_count.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -69,11 +69,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Eth1DataVote::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/exit.rs

@@ -37,11 +37,11 @@ impl Decodable for Exit {
 }
 
 impl TreeHash for Exit {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.epoch.hash_tree_root());
-        result.append(&mut self.validator_index.hash_tree_root());
-        result.append(&mut self.signature.hash_tree_root());
+        result.append(&mut self.epoch.hash_tree_root_internal());
+        result.append(&mut self.validator_index.hash_tree_root_internal());
+        result.append(&mut self.signature.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -74,11 +74,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Exit::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/fork.rs

@@ -36,11 +36,11 @@ impl Decodable for Fork {
 }
 
 impl TreeHash for Fork {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.previous_version.hash_tree_root());
-        result.append(&mut self.current_version.hash_tree_root());
-        result.append(&mut self.epoch.hash_tree_root());
+        result.append(&mut self.previous_version.hash_tree_root_internal());
+        result.append(&mut self.current_version.hash_tree_root_internal());
+        result.append(&mut self.epoch.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -73,11 +73,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Fork::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/pending_attestation.rs

@@ -41,12 +41,12 @@ impl Decodable for PendingAttestation {
 }
 
 impl TreeHash for PendingAttestation {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.aggregation_bitfield.hash_tree_root());
-        result.append(&mut self.data.hash_tree_root());
-        result.append(&mut self.custody_bitfield.hash_tree_root());
-        result.append(&mut self.inclusion_slot.hash_tree_root());
+        result.append(&mut self.aggregation_bitfield.hash_tree_root_internal());
+        result.append(&mut self.data.hash_tree_root_internal());
+        result.append(&mut self.custody_bitfield.hash_tree_root_internal());
+        result.append(&mut self.inclusion_slot.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -80,11 +80,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = PendingAttestation::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/proposal_signed_data.rs

@@ -37,11 +37,11 @@ impl Decodable for ProposalSignedData {
 }
 
 impl TreeHash for ProposalSignedData {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.shard.hash_tree_root());
-        result.append(&mut self.block_root.hash_tree_root());
+        result.append(&mut self.slot.hash_tree_root_internal());
+        result.append(&mut self.shard.hash_tree_root_internal());
+        result.append(&mut self.block_root.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -74,11 +74,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = ProposalSignedData::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/proposer_slashing.rs

@@ -46,13 +46,13 @@ impl Decodable for ProposerSlashing {
 }
 
 impl TreeHash for ProposerSlashing {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.proposer_index.hash_tree_root());
-        result.append(&mut self.proposal_data_1.hash_tree_root());
-        result.append(&mut self.proposal_signature_1.hash_tree_root());
-        result.append(&mut self.proposal_data_2.hash_tree_root());
-        result.append(&mut self.proposal_signature_2.hash_tree_root());
+        result.append(&mut self.proposer_index.hash_tree_root_internal());
+        result.append(&mut self.proposal_data_1.hash_tree_root_internal());
+        result.append(&mut self.proposal_signature_1.hash_tree_root_internal());
+        result.append(&mut self.proposal_data_2.hash_tree_root_internal());
+        result.append(&mut self.proposal_signature_2.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -87,11 +87,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = ProposerSlashing::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/shard_reassignment_record.rs

@@ -36,11 +36,11 @@ impl Decodable for ShardReassignmentRecord {
 }
 
 impl TreeHash for ShardReassignmentRecord {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.validator_index.hash_tree_root());
-        result.append(&mut self.shard.hash_tree_root());
-        result.append(&mut self.slot.hash_tree_root());
+        result.append(&mut self.validator_index.hash_tree_root_internal());
+        result.append(&mut self.shard.hash_tree_root_internal());
+        result.append(&mut self.slot.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -73,11 +73,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = ShardReassignmentRecord::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/slashable_attestation.rs

@@ -40,12 +40,12 @@ impl Decodable for SlashableAttestation {
 }
 
 impl TreeHash for SlashableAttestation {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.validator_indices.hash_tree_root());
-        result.append(&mut self.data.hash_tree_root());
-        result.append(&mut self.custody_bitfield.hash_tree_root());
-        result.append(&mut self.aggregate_signature.hash_tree_root());
+        result.append(&mut self.validator_indices.hash_tree_root_internal());
+        result.append(&mut self.data.hash_tree_root_internal());
+        result.append(&mut self.custody_bitfield.hash_tree_root_internal());
+        result.append(&mut self.aggregate_signature.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -79,11 +79,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = SlashableAttestation::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/slashable_vote_data.rs

@@ -64,12 +64,12 @@ impl Decodable for SlashableVoteData {
 }
 
 impl TreeHash for SlashableVoteData {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.custody_bit_0_indices.hash_tree_root());
-        result.append(&mut self.custody_bit_1_indices.hash_tree_root());
-        result.append(&mut self.data.hash_tree_root());
-        result.append(&mut self.aggregate_signature.hash_tree_root());
+        result.append(&mut self.custody_bit_0_indices.hash_tree_root_internal());
+        result.append(&mut self.custody_bit_1_indices.hash_tree_root_internal());
+        result.append(&mut self.data.hash_tree_root_internal());
+        result.append(&mut self.aggregate_signature.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -177,11 +177,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = SlashableVoteData::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/slot_epoch_macros.rs

@@ -224,9 +224,9 @@ macro_rules! impl_ssz {
         }
 
         impl TreeHash for $type {
-            fn hash_tree_root(&self) -> Vec<u8> {
+            fn hash_tree_root_internal(&self) -> Vec<u8> {
                 let mut result: Vec<u8> = vec![];
-                result.append(&mut self.0.hash_tree_root());
+                result.append(&mut self.0.hash_tree_root_internal());
                 hash(&result)
             }
         }
@@ -560,11 +560,11 @@ macro_rules! ssz_tests {
         }
 
         #[test]
-        pub fn test_hash_tree_root() {
+        pub fn test_hash_tree_root_internal() {
             let mut rng = XorShiftRng::from_seed([42; 16]);
             let original = $type::random_for_test(&mut rng);
 
-            let result = original.hash_tree_root();
+            let result = original.hash_tree_root_internal();
 
             assert_eq!(result.len(), 32);
             // TODO: Add further tests

eth2/types/src/validator.rs

@@ -122,15 +122,17 @@ impl Decodable for Validator {
 }
 
 impl TreeHash for Validator {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.pubkey.hash_tree_root());
-        result.append(&mut self.withdrawal_credentials.hash_tree_root());
-        result.append(&mut self.activation_epoch.hash_tree_root());
-        result.append(&mut self.exit_epoch.hash_tree_root());
-        result.append(&mut self.withdrawal_epoch.hash_tree_root());
-        result.append(&mut self.penalized_epoch.hash_tree_root());
-        result.append(&mut u64::from(status_flag_to_byte(self.status_flags)).hash_tree_root());
+        result.append(&mut self.pubkey.hash_tree_root_internal());
+        result.append(&mut self.withdrawal_credentials.hash_tree_root_internal());
+        result.append(&mut self.activation_epoch.hash_tree_root_internal());
+        result.append(&mut self.exit_epoch.hash_tree_root_internal());
+        result.append(&mut self.withdrawal_epoch.hash_tree_root_internal());
+        result.append(&mut self.penalized_epoch.hash_tree_root_internal());
+        result.append(
+            &mut u64::from(status_flag_to_byte(self.status_flags)).hash_tree_root_internal(),
+        );
         hash(&result)
     }
 }
@@ -190,11 +192,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = Validator::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/types/src/validator_registry_delta_block.rs

@@ -59,13 +59,13 @@ impl Decodable for ValidatorRegistryDeltaBlock {
 }
 
 impl TreeHash for ValidatorRegistryDeltaBlock {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
-        result.append(&mut self.latest_registry_delta_root.hash_tree_root());
-        result.append(&mut self.validator_index.hash_tree_root());
-        result.append(&mut self.pubkey.hash_tree_root());
-        result.append(&mut self.slot.hash_tree_root());
-        result.append(&mut self.flag.hash_tree_root());
+        result.append(&mut self.latest_registry_delta_root.hash_tree_root_internal());
+        result.append(&mut self.validator_index.hash_tree_root_internal());
+        result.append(&mut self.pubkey.hash_tree_root_internal());
+        result.append(&mut self.slot.hash_tree_root_internal());
+        result.append(&mut self.flag.hash_tree_root_internal());
         hash(&result)
     }
 }
@@ -100,11 +100,11 @@ mod tests {
     }
 
     #[test]
-    pub fn test_hash_tree_root() {
+    pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
         let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng);
 
-        let result = original.hash_tree_root();
+        let result = original.hash_tree_root_internal();
 
         assert_eq!(result.len(), 32);
         // TODO: Add further tests

eth2/utils/bls/src/aggregate_signature.rs

@@ -57,7 +57,7 @@ impl Serialize for AggregateSignature {
 }
 
 impl TreeHash for AggregateSignature {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         hash(&self.0.as_bytes())
     }
 }

eth2/utils/bls/src/public_key.rs

@@ -66,7 +66,7 @@ impl Serialize for PublicKey {
 }
 
 impl TreeHash for PublicKey {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         hash(&self.0.as_bytes())
     }
 }

eth2/utils/bls/src/secret_key.rs

@@ -41,7 +41,7 @@ impl Decodable for SecretKey {
 }
 
 impl TreeHash for SecretKey {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         self.0.as_bytes().clone()
     }
 }

eth2/utils/bls/src/signature.rs

@@ -61,7 +61,7 @@ impl Decodable for Signature {
 }
 
 impl TreeHash for Signature {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         hash(&self.0.as_bytes())
     }
 }

eth2/utils/boolean-bitfield/src/lib.rs

@@ -187,8 +187,8 @@ impl Serialize for BooleanBitfield {
 }
 
 impl ssz::TreeHash for BooleanBitfield {
-    fn hash_tree_root(&self) -> Vec<u8> {
-        self.to_bytes().hash_tree_root()
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
+        self.to_bytes().hash_tree_root_internal()
     }
 }
 

eth2/utils/ssz/src/impl_tree_hash.rs

@@ -3,49 +3,49 @@ use super::{merkle_hash, ssz_encode, TreeHash};
 use hashing::hash;
 
 impl TreeHash for u8 {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for u16 {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for u32 {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for u64 {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for usize {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for Address {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for H256 {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         ssz_encode(self)
     }
 }
 
 impl TreeHash for [u8] {
-    fn hash_tree_root(&self) -> Vec<u8> {
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
         if self.len() > 32 {
             return hash(&self);
         }
@@ -57,12 +57,12 @@ impl<T> TreeHash for Vec<T>
 where
     T: TreeHash,
 {
-    /// Returns the merkle_hash of a list of hash_tree_root values created
+    /// Returns the merkle_hash of a list of hash_tree_root_internal values created
     /// from the given list.
     /// Note: A byte vector, Vec<u8>, must be converted to a slice (as_slice())
     ///       to be handled properly (i.e. hashed) as byte array.
-    fn hash_tree_root(&self) -> Vec<u8> {
-        let mut tree_hashes = self.iter().map(|x| x.hash_tree_root()).collect();
+    fn hash_tree_root_internal(&self) -> Vec<u8> {
+        let mut tree_hashes = self.iter().map(|x| x.hash_tree_root_internal()).collect();
         merkle_hash(&mut tree_hashes)
     }
 }
@@ -73,7 +73,7 @@ mod tests {
 
     #[test]
     fn test_impl_tree_hash_vec() {
-        let result = vec![1u32, 2, 3, 4, 5, 6, 7].hash_tree_root();
+        let result = vec![1u32, 2, 3, 4, 5, 6, 7].hash_tree_root_internal();
         assert_eq!(result.len(), 32);
     }
 }

eth2/utils/ssz/src/tree_hash.rs

@@ -4,7 +4,14 @@ const SSZ_CHUNK_SIZE: usize = 128;
 const HASHSIZE: usize = 32;
 
 pub trait TreeHash {
-    fn hash_tree_root(&self) -> Vec<u8>;
+    fn hash_tree_root_internal(&self) -> Vec<u8>;
+    fn hash_tree_root(&self) -> Vec<u8> {
+        let mut result = self.hash_tree_root_internal();
+        if result.len() < HASHSIZE {
+            zpad(&mut result, HASHSIZE);
+        }
+        result
+    }
 }
 
 /// Returns a 32 byte hash of 'list' - a vector of byte vectors.
@@ -14,7 +21,8 @@ pub fn merkle_hash(list: &mut Vec<Vec<u8>>) -> Vec<u8> {
     let (mut chunk_size, mut chunkz) = list_to_blob(list);
 
     // get data_len as bytes. It will hashed will the merkle root
-    let datalen = list.len().to_le_bytes();
+    let mut datalen = list.len().to_le_bytes().to_vec();
+    zpad(&mut datalen, 32);
 
     // Tree-hash
     while chunkz.len() > HASHSIZE {
@@ -36,33 +44,68 @@ pub fn merkle_hash(list: &mut Vec<Vec<u8>>) -> Vec<u8> {
         chunkz = new_chunkz;
     }
 
-    chunkz.append(&mut datalen.to_vec());
+    chunkz.append(&mut datalen);
     hash(&chunkz)
 }
 
 fn list_to_blob(list: &mut Vec<Vec<u8>>) -> (usize, Vec<u8>) {
-    let chunk_size = if list.is_empty() {
+    let chunk_size = if list.is_empty() || list[0].len() < SSZ_CHUNK_SIZE {
         SSZ_CHUNK_SIZE
-    } else if list[0].len() < SSZ_CHUNK_SIZE {
-        let items_per_chunk = SSZ_CHUNK_SIZE / list[0].len();
-        items_per_chunk * list[0].len()
     } else {
         list[0].len()
     };
 
-    let mut data = Vec::new();
+    let (items_per_chunk, chunk_count) = if list.is_empty() {
+        (1, 1)
+    } else {
+        let items_per_chunk = SSZ_CHUNK_SIZE / list[0].len();
+        let chunk_count = list.len() / items_per_chunk;
+        (items_per_chunk, chunk_count)
+    };
+
+    let mut chunkz = Vec::new();
     if list.is_empty() {
         // handle and empty list
-        data.append(&mut vec![0; SSZ_CHUNK_SIZE]);
-    } else {
+        chunkz.append(&mut vec![0; SSZ_CHUNK_SIZE]);
+    } else if list[0].len() <= SSZ_CHUNK_SIZE {
         // just create a blob here; we'll divide into
         // chunked slices when we merklize
-        data.reserve(list[0].len() * list.len());
+        let mut chunk = Vec::with_capacity(chunk_size);
+        let mut item_count_in_chunk = 0;
+        chunkz.reserve(chunk_count * chunk_size);
         for item in list.iter_mut() {
-            data.append(item);
+            item_count_in_chunk += 1;
+            chunk.append(item);
+
+            // completed chunk?
+            if item_count_in_chunk == items_per_chunk {
+                zpad(&mut chunk, chunk_size);
+                chunkz.append(&mut chunk);
+                item_count_in_chunk = 0;
+            }
+        }
+
+        // left-over uncompleted chunk?
+        if item_count_in_chunk != 0 {
+            zpad(&mut chunk, chunk_size);
+            chunkz.append(&mut chunk);
+        }
+    } else {
+        // chunks larger than SSZ_CHUNK_SIZE
+        chunkz.reserve(chunk_count * chunk_size);
+        for item in list.iter_mut() {
+            chunkz.append(item);
         }
     }
-    (chunk_size, data)
+
+    (chunk_size, chunkz)
+}
+
+/// right pads with zeros making 'bytes' 'size' in length
+fn zpad(bytes: &mut Vec<u8>, size: usize) {
+    if bytes.len() < size {
+        bytes.resize(size, 0);
+    }
 }
 
 #[cfg(test)]