Add transfer processing to BeaconChain

beacon_node/beacon_chain/test_harness/src/test_case/config.rs

@@ -10,6 +10,8 @@ pub type DepositTuple = (SlotHeight, GweiAmount);
 pub type ExitTuple = (SlotHeight, ValidatorIndex);
 pub type ProposerSlashingTuple = (SlotHeight, ValidatorIndex);
 pub type AttesterSlashingTuple = (SlotHeight, ValidatorIndices);
+/// (slot_height, from, to, amount)
+pub type TransferTuple = (SlotHeight, ValidatorIndex, ValidatorIndex, GweiAmount);
 
 /// Defines the execution of a `BeaconStateHarness` across a series of slots.
 #[derive(Debug)]
@@ -30,6 +32,8 @@ pub struct Config {
     pub attester_slashings: Option<Vec<AttesterSlashingTuple>>,
     /// Exits to be including during execution.
     pub exits: Option<Vec<ExitTuple>>,
+    /// Transfers to be including during execution.
+    pub transfers: Option<Vec<TransferTuple>>,
 }
 
 impl Config {
@@ -47,10 +51,27 @@ impl Config {
             proposer_slashings: parse_proposer_slashings(&yaml),
             attester_slashings: parse_attester_slashings(&yaml),
             exits: parse_exits(&yaml),
+            transfers: parse_transfers(&yaml),
         }
     }
 }
 
+/// Parse the `transfers` section of the YAML document.
+fn parse_transfers(yaml: &Yaml) -> Option<Vec<TransferTuple>> {
+    let mut tuples = vec![];
+
+    for exit in yaml["transfers"].as_vec()? {
+        let slot = as_u64(exit, "slot").expect("Incomplete transfer (slot)");
+        let from = as_u64(exit, "from").expect("Incomplete transfer (from)");
+        let to = as_u64(exit, "to").expect("Incomplete transfer (to)");
+        let amount = as_u64(exit, "amount").expect("Incomplete transfer (amount)");
+
+        tuples.push((SlotHeight::from(slot), from, to, amount));
+    }
+
+    Some(tuples)
+}
+
 /// Parse the `attester_slashings` section of the YAML document.
 fn parse_exits(yaml: &Yaml) -> Option<Vec<ExitTuple>> {
     let mut tuples = vec![];
@@ -102,8 +123,7 @@ fn parse_deposits(yaml: &Yaml) -> Option<Vec<DepositTuple>> {
 
     for deposit in yaml["deposits"].as_vec()? {
         let slot = as_u64(deposit, "slot").expect("Incomplete deposit (slot)");
-        let amount =
-            as_u64(deposit, "amount").expect("Incomplete deposit (amount)") * 1_000_000_000;
+        let amount = as_u64(deposit, "amount").expect("Incomplete deposit (amount)");
 
         deposits.push((SlotHeight::from(slot), amount))
     }

beacon_node/beacon_chain/test_harness/src/test_case/state_check.rs

@@ -3,6 +3,11 @@ use log::info;
 use types::*;
 use yaml_rust::Yaml;
 
+type ValidatorIndex = u64;
+type BalanceGwei = u64;
+
+type BalanceCheckTuple = (ValidatorIndex, String, BalanceGwei);
+
 /// Tests to be conducted upon a `BeaconState` object generated during the execution of a
 /// `TestCase`.
 #[derive(Debug)]
@@ -17,6 +22,8 @@ pub struct StateCheck {
     pub exited_validators: Option<Vec<u64>>,
     /// A list of validator indices which have had an exit initiated. Must be in ascending order.
     pub exit_initiated_validators: Option<Vec<u64>>,
+    /// A list of balances to check.
+    pub balances: Option<Vec<BalanceCheckTuple>>,
 }
 
 impl StateCheck {
@@ -30,6 +37,7 @@ impl StateCheck {
             slashed_validators: as_vec_u64(&yaml, "slashed_validators"),
             exited_validators: as_vec_u64(&yaml, "exited_validators"),
             exit_initiated_validators: as_vec_u64(&yaml, "exit_initiated_validators"),
+            balances: parse_balances(&yaml),
         }
     }
 
@@ -124,5 +132,47 @@ impl StateCheck {
                 exit_initiated_validators
             );
         }
+
+        // Check validator balances.
+        if let Some(ref balances) = self.balances {
+            for (index, comparison, expected) in balances {
+                let actual = *state
+                    .validator_balances
+                    .get(*index as usize)
+                    .expect("Balance check specifies unknown validator");
+
+                let result = match comparison.as_ref() {
+                    "eq" => actual == *expected,
+                    _ => panic!("Unknown balance comparison (use `eq`)"),
+                };
+                assert!(
+                    result,
+                    format!(
+                        "Validator balance for {}: {} !{} {}.",
+                        index, actual, comparison, expected
+                    )
+                );
+                info!("OK: validator balance for {:?}.", index);
+            }
+        }
     }
 }
+
+/// Parse the `transfers` section of the YAML document.
+fn parse_balances(yaml: &Yaml) -> Option<Vec<BalanceCheckTuple>> {
+    let mut tuples = vec![];
+
+    for exit in yaml["balances"].as_vec()? {
+        let from =
+            as_u64(exit, "validator_index").expect("Incomplete balance check (validator_index)");
+        let comparison = exit["comparison"]
+            .clone()
+            .into_string()
+            .expect("Incomplete balance check (amount)");
+        let balance = as_u64(exit, "balance").expect("Incomplete balance check (balance)");
+
+        tuples.push((from, comparison, balance));
+    }
+
+    Some(tuples)
+}