Add block and attestation validation

Cargo.toml

@@ -39,5 +39,6 @@ members = [
 	"beacon_chain/utils/shuffling",
 	"beacon_chain/utils/ssz",
 	"beacon_chain/utils/ssz_helpers",
+	"beacon_chain/validation",
 	"lighthouse/db",
 ]

beacon_chain/validation/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "validation"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+
+[dependencies]
+bls = { path = "../utils/bls" }
+db = { path = "../../lighthouse/db" }
+hashing = { path = "../utils/hashing" }
+rayon = "1.0.2"
+ssz = { path = "../utils/ssz" }
+ssz_helpers = { path = "../utils/ssz_helpers" }
+types = { path = "../types" }

beacon_chain/validation/src/attestation_parent_hashes.rs

@@ -0,0 +1,226 @@
+use super::types::Hash256;
+
+#[derive(Debug)]
+pub enum ParentHashesError {
+    BadCurrentHashes,
+    BadObliqueHashes,
+    SlotTooHigh,
+    SlotTooLow,
+    IntWrapping,
+}
+
+/// This function is used to select the hashes used in
+/// the signing of an AttestationRecord.
+///
+/// It either returns Result with a vector of length `cycle_length,` or
+/// returns an Error.
+///
+/// This function corresponds to the `get_signed_parent_hashes` function
+/// in the Python reference implentation.
+///
+/// See this slide for more information:
+/// https://tinyurl.com/ybzn2spw
+pub fn attestation_parent_hashes(
+    cycle_length: u8,
+    block_slot: u64,
+    attestation_slot: u64,
+    current_hashes: &[Hash256],
+    oblique_hashes: &[Hash256])
+    -> Result<Vec<Hash256>, ParentHashesError>
+{
+    // This cast places a limit on cycle_length. If you change it, check math
+    // for overflow.
+    let cycle_length: u64 = u64::from(cycle_length);
+
+    if current_hashes.len() as u64 != (cycle_length * 2) {
+        return Err(ParentHashesError::BadCurrentHashes);
+    }
+    if oblique_hashes.len() as u64 > cycle_length {
+        return Err(ParentHashesError::BadObliqueHashes);
+    }
+    if attestation_slot >= block_slot {
+        return Err(ParentHashesError::SlotTooHigh);
+    }
+
+    /*
+     * Cannot underflow as block_slot cannot be less
+     * than attestation_slot.
+     */
+    let attestation_distance = block_slot - attestation_slot;
+
+    if attestation_distance > cycle_length {
+        return Err(ParentHashesError::SlotTooLow);
+    }
+
+    /*
+     * Cannot underflow because attestation_distance cannot
+     * be larger than cycle_length.
+     */
+    let start = cycle_length - attestation_distance;
+
+    /*
+     * Overflow is potentially impossible, but proof is complicated
+     * enough to just use checked math.
+     *
+     * Arithmetic is:
+     * start + cycle_length - oblique_hashes.len()
+     */
+    let end = start.checked_add(cycle_length)
+        .and_then(|x| x.checked_sub(oblique_hashes.len() as u64))
+        .ok_or(ParentHashesError::IntWrapping)?;
+
+
+    let mut hashes = Vec::new();
+    hashes.extend_from_slice(
+        &current_hashes[(start as usize)..(end as usize)]);
+    hashes.extend_from_slice(oblique_hashes);
+
+    Ok(hashes)
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn get_range_of_hashes(from: usize, to: usize) -> Vec<Hash256> {
+        (from..to).map(|i| get_hash(&vec![i as u8])).collect()
+    }
+
+    fn get_hash(value: &[u8]) -> Hash256 {
+        Hash256::from_slice(value)
+    }
+
+    #[test]
+    fn test_get_signed_hashes_oblique_scenario_1() {
+        /*
+         * Two oblique hashes.
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 19;
+        let attestation_slot: u64 = 15;
+        let current_hashes = get_range_of_hashes(3, 19);
+        let oblique_hashes = get_range_of_hashes(100, 102);
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.len(), cycle_length as usize);
+
+        let mut expected_result = get_range_of_hashes(7, 13);
+        expected_result.append(&mut get_range_of_hashes(100, 102));
+        assert_eq!(result, expected_result);
+    }
+
+    #[test]
+    fn test_get_signed_hashes_oblique_scenario_2() {
+        /*
+         * All oblique hashes.
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 19;
+        let attestation_slot: u64 = 15;
+        let current_hashes = get_range_of_hashes(3, 19);
+        let oblique_hashes = get_range_of_hashes(100, 108);
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.len(), cycle_length as usize);
+
+        let expected_result = get_range_of_hashes(100, 108);
+        assert_eq!(result, expected_result);
+    }
+
+    #[test]
+    fn test_get_signed_hashes_scenario_1() {
+        /*
+         * Google Slides example.
+         * https://tinyurl.com/ybzn2spw
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 19;
+        let attestation_slot: u64 = 15;
+        let current_hashes = get_range_of_hashes(3, 19);
+        let oblique_hashes = vec![];
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        assert!(result.is_ok());
+        let result = result.unwrap();
+        assert_eq!(result.len(), cycle_length as usize);
+        let expected_result = get_range_of_hashes(7, 15);
+        assert_eq!(result, expected_result);
+    }
+
+    #[test]
+    fn test_get_signed_hashes_scenario_2() {
+        /*
+         * Block 1, attestation 0.
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 1;
+        let attestation_slot: u64 = 0;
+        let current_hashes = get_range_of_hashes(0, 16);
+        let oblique_hashes = vec![];
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        let result = result.unwrap();
+        assert_eq!(result.len(), cycle_length as usize);
+        let expected_result = get_range_of_hashes(7, 15);
+        assert_eq!(result, expected_result);
+    }
+
+    #[test]
+    fn test_get_signed_hashes_scenario_3() {
+        /*
+         * attestation_slot too large
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 100;
+        let attestation_slot: u64 = 100;
+        let current_hashes = get_range_of_hashes(0, 16);
+        let oblique_hashes = vec![];
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_get_signed_hashes_scenario_4() {
+        /*
+         * Current hashes too small
+         */
+        let cycle_length: u8 = 8;
+        let block_slot: u64 = 100;
+        let attestation_slot: u64 = 99;
+        let current_hashes = get_range_of_hashes(0, 15);
+        let oblique_hashes = vec![];
+        let result = attestation_parent_hashes(
+            cycle_length,
+            block_slot,
+            attestation_slot,
+            &current_hashes,
+            &oblique_hashes);
+        assert!(result.is_err());
+    }
+}