diff --git a/eth2/attestation_validation/src/justified_block.rs b/eth2/attestation_validation/src/justified_block.rs index e910819c8..c4c3baa1f 100644 --- a/eth2/attestation_validation/src/justified_block.rs +++ b/eth2/attestation_validation/src/justified_block.rs @@ -31,7 +31,7 @@ where None => reject!(Invalid::JustifiedBlockNotInChain), Some(local_justified_block_hash) => { verify_or!( - data.justified_block_hash == local_justified_block_hash, + data.justified_block_root == local_justified_block_hash, reject!(Invalid::JustifiedBlockHashMismatch) ); } diff --git a/eth2/attestation_validation/src/shard_block.rs b/eth2/attestation_validation/src/shard_block.rs index e1d9487de..ac5b0a067 100644 --- a/eth2/attestation_validation/src/shard_block.rs +++ b/eth2/attestation_validation/src/shard_block.rs @@ -21,8 +21,8 @@ where Some(crosslink) => { let local_shard_block_hash = crosslink.shard_block_root; let shard_block_hash_is_permissable = { - (local_shard_block_hash == data.latest_crosslink_hash) - || (local_shard_block_hash == data.shard_block_hash) + (local_shard_block_hash == data.latest_crosslink_root) + || (local_shard_block_hash == data.shard_block_root) }; verify_or!( shard_block_hash_is_permissable, diff --git a/eth2/genesis/src/beacon_block.rs b/eth2/genesis/src/beacon_block.rs index 3fefff6a0..e79e3d2f4 100644 --- a/eth2/genesis/src/beacon_block.rs +++ b/eth2/genesis/src/beacon_block.rs @@ -1,14 +1,17 @@ use spec::ChainSpec; -use types::{BeaconBlock, BeaconBlockBody, Hash256}; +use types::{BeaconBlock, BeaconBlockBody, Eth1Data, Hash256}; /// Generate a genesis BeaconBlock. pub fn genesis_beacon_block(state_root: Hash256, spec: &ChainSpec) -> BeaconBlock { BeaconBlock { - slot: spec.genesis_slot_number, + slot: spec.genesis_slot, parent_root: spec.zero_hash, state_root, - randao_reveal: spec.zero_hash, - candidate_pow_receipt_root: spec.zero_hash, + randao_reveal: spec.empty_signature.clone(), + eth1_data: Eth1Data { + deposit_root: spec.zero_hash, + block_hash: spec.zero_hash, + }, signature: spec.empty_signature.clone(), body: BeaconBlockBody { proposer_slashings: vec![], @@ -47,8 +50,9 @@ mod tests { assert!(genesis_block.slot == 0); assert!(genesis_block.parent_root.is_zero()); - assert!(genesis_block.randao_reveal.is_zero()); - assert!(genesis_block.candidate_pow_receipt_root.is_zero()); // aka deposit_root + assert_eq!(genesis_block.randao_reveal, Signature::empty_signature()); + assert!(genesis_block.eth1_data.deposit_root.is_zero()); + assert!(genesis_block.eth1_data.block_hash.is_zero()); } #[test] diff --git a/eth2/genesis/src/beacon_state.rs b/eth2/genesis/src/beacon_state.rs index 54cf1388d..7644e782b 100644 --- a/eth2/genesis/src/beacon_state.rs +++ b/eth2/genesis/src/beacon_state.rs @@ -1,5 +1,5 @@ use spec::ChainSpec; -use types::{BeaconState, CrosslinkRecord, ForkData}; +use types::{BeaconState, Crosslink, Fork}; use validator_shuffling::{shard_and_committees_for_cycle, ValidatorAssignmentError}; #[derive(Debug, PartialEq)] @@ -20,8 +20,8 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result { a }; - let initial_crosslink = CrosslinkRecord { - slot: spec.genesis_slot_number, + let initial_crosslink = Crosslink { + slot: spec.genesis_slot, shard_block_root: spec.zero_hash, }; @@ -29,19 +29,19 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result { /* * Misc */ - slot: spec.genesis_slot_number, + slot: spec.genesis_slot, genesis_time: spec.genesis_time, - fork_data: ForkData { + fork_data: Fork { pre_fork_version: spec.genesis_fork_version, post_fork_version: spec.genesis_fork_version, - fork_slot: spec.genesis_slot_number, + fork_slot: spec.genesis_slot, }, /* * Validator registry */ validator_registry: spec.initial_validators.clone(), validator_balances: spec.initial_balances.clone(), - validator_registry_latest_change_slot: spec.genesis_slot_number, + validator_registry_update_slot: spec.genesis_slot, validator_registry_exit_count: 0, validator_registry_delta_chain_tip: spec.zero_hash, /* @@ -54,8 +54,8 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result { ], previous_epoch_start_shard: spec.genesis_start_shard, current_epoch_start_shard: spec.genesis_start_shard, - previous_epoch_calculation_slot: spec.genesis_slot_number, - current_epoch_calculation_slot: spec.genesis_slot_number, + previous_epoch_calculation_slot: spec.genesis_slot, + current_epoch_calculation_slot: spec.genesis_slot, previous_epoch_randao_mix: spec.zero_hash, current_epoch_randao_mix: spec.zero_hash, /* @@ -65,10 +65,10 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result { /* * Finality */ - previous_justified_slot: spec.genesis_slot_number, - justified_slot: spec.genesis_slot_number, + previous_justified_slot: spec.genesis_slot, + justified_slot: spec.genesis_slot, justification_bitfield: 0, - finalized_slot: spec.genesis_slot_number, + finalized_slot: spec.genesis_slot, /* * Recent state */ @@ -80,8 +80,8 @@ pub fn genesis_beacon_state(spec: &ChainSpec) -> Result { /* * PoW receipt root */ - processed_pow_receipt_root: spec.processed_pow_receipt_root, - candidate_pow_receipt_roots: vec![], + latest_eth1_data: spec.intial_eth1_data.clone(), + eth1_data_votes: vec![], }) } @@ -129,7 +129,7 @@ mod tests { assert_eq!(state.validator_registry, spec.initial_validators); assert_eq!(state.validator_balances, spec.initial_balances); - assert!(state.validator_registry_latest_change_slot == 0); + assert!(state.validator_registry_update_slot == 0); assert!(state.validator_registry_exit_count == 0); assert_eq!(state.validator_registry_delta_chain_tip, Hash256::zero()); } @@ -213,10 +213,7 @@ mod tests { let state = genesis_beacon_state(&spec).unwrap(); - assert_eq!( - state.processed_pow_receipt_root, - spec.processed_pow_receipt_root - ); - assert!(state.candidate_pow_receipt_roots.is_empty()); + assert_eq!(&state.latest_eth1_data, &spec.intial_eth1_data); + assert!(state.eth1_data_votes.is_empty()); } } diff --git a/eth2/spec/src/foundation.rs b/eth2/spec/src/foundation.rs index 81bee7c4a..8508a74e1 100644 --- a/eth2/spec/src/foundation.rs +++ b/eth2/spec/src/foundation.rs @@ -1,7 +1,7 @@ use super::ChainSpec; use bls::{Keypair, PublicKey, SecretKey, Signature}; -use types::{Address, Hash256, ValidatorRecord}; +use types::{Address, Eth1Data, Hash256, Validator}; /// The size of a validators deposit in GWei. pub const DEPOSIT_GWEI: u64 = 32_000_000_000; @@ -18,9 +18,8 @@ impl ChainSpec { */ shard_count: 1_024, target_committee_size: 128, - ejection_balance: 16, + ejection_balance: 16 * u64::pow(10, 9), max_balance_churn_quotient: 32, - gwei_per_eth: u64::pow(10, 9), beacon_chain_shard_number: u64::max_value(), max_casper_votes: 1_024, latest_block_roots_length: 8_192, @@ -32,13 +31,13 @@ impl ChainSpec { */ deposit_contract_address: Address::from("TBD".as_bytes()), deposit_contract_tree_depth: 32, - min_deposit: 1, - max_deposit: 32, + min_deposit: 1 * u64::pow(10, 9), + max_deposit: 32 * u64::pow(10, 9), /* * Initial Values */ genesis_fork_version: 0, - genesis_slot_number: 0, + genesis_slot: 0, genesis_start_shard: 0, far_future_slot: u64::max_value(), zero_hash: Hash256::zero(), @@ -52,12 +51,12 @@ impl ChainSpec { epoch_length: 64, seed_lookahead: 64, entry_exit_delay: 256, - pow_receipt_root_voting_period: 1_024, + eth1_data_voting_period: 1_024, min_validator_withdrawal_time: u64::pow(2, 14), /* * Reward and penalty quotients */ - base_reward_quotient: 1_024, + base_reward_quotient: 32, whistleblower_reward_quotient: 512, includer_reward_quotient: 8, inactivity_penalty_quotient: u64::pow(2, 24), @@ -75,13 +74,16 @@ impl ChainSpec { initial_validators: initial_validators_for_testing(), initial_balances: initial_balances_for_testing(), genesis_time: 1_544_672_897, - processed_pow_receipt_root: Hash256::from("pow_root".as_bytes()), + intial_eth1_data: Eth1Data { + deposit_root: Hash256::from("deposit_root".as_bytes()), + block_hash: Hash256::from("block_hash".as_bytes()), + }, } } } /// Generate a set of validator records to use with testing until the real chain starts. -fn initial_validators_for_testing() -> Vec { +fn initial_validators_for_testing() -> Vec { // Some dummy private keys to start with. let key_strings = vec![ "jzjxxgjajfjrmgodszzsgqccmhnyvetcuxobhtynojtpdtbj", @@ -104,22 +106,20 @@ fn initial_validators_for_testing() -> Vec { pk: public_key, } }; - let validator_record = ValidatorRecord { + let validator = Validator { pubkey: keypair.pk.clone(), withdrawal_credentials: Hash256::zero(), - randao_commitment: Hash256::zero(), - randao_layers: 0, + proposer_slots: 0, activation_slot: u64::max_value(), exit_slot: u64::max_value(), withdrawal_slot: u64::max_value(), penalized_slot: u64::max_value(), exit_count: 0, status_flags: None, - custody_commitment: Hash256::zero(), latest_custody_reseed_slot: 0, penultimate_custody_reseed_slot: 0, }; - initial_validators.push(validator_record); + initial_validators.push(validator); } initial_validators diff --git a/eth2/spec/src/lib.rs b/eth2/spec/src/lib.rs index fbe82794d..3e7d5dd2b 100644 --- a/eth2/spec/src/lib.rs +++ b/eth2/spec/src/lib.rs @@ -4,7 +4,7 @@ extern crate types; mod foundation; use bls::Signature; -use types::{Address, Hash256, ValidatorRecord}; +use types::{Address, Eth1Data, Hash256, Validator}; #[derive(PartialEq, Debug)] pub struct ChainSpec { @@ -15,7 +15,6 @@ pub struct ChainSpec { pub target_committee_size: u64, pub ejection_balance: u64, pub max_balance_churn_quotient: u64, - pub gwei_per_eth: u64, pub beacon_chain_shard_number: u64, pub max_casper_votes: u64, pub latest_block_roots_length: u64, @@ -33,7 +32,7 @@ pub struct ChainSpec { * Initial Values */ pub genesis_fork_version: u64, - pub genesis_slot_number: u64, + pub genesis_slot: u64, pub genesis_start_shard: u64, pub far_future_slot: u64, pub zero_hash: Hash256, @@ -47,7 +46,7 @@ pub struct ChainSpec { pub epoch_length: u64, pub seed_lookahead: u64, pub entry_exit_delay: u64, - pub pow_receipt_root_voting_period: u64, // a.k.a. deposit_root_voting_period + pub eth1_data_voting_period: u64, pub min_validator_withdrawal_time: u64, /* * Reward and penalty quotients @@ -67,8 +66,8 @@ pub struct ChainSpec { /* * Intialization parameters */ - pub initial_validators: Vec, + pub initial_validators: Vec, pub initial_balances: Vec, pub genesis_time: u64, - pub processed_pow_receipt_root: Hash256, + pub intial_eth1_data: Eth1Data, } diff --git a/eth2/types/src/attestation.rs b/eth2/types/src/attestation.rs index fb8b946a5..bef35bc78 100644 --- a/eth2/types/src/attestation.rs +++ b/eth2/types/src/attestation.rs @@ -7,32 +7,32 @@ use rand::RngCore; #[derive(Debug, Clone, PartialEq)] pub struct Attestation { pub data: AttestationData, - pub participation_bitfield: Bitfield, + pub aggregation_bitfield: Bitfield, pub custody_bitfield: Bitfield, - pub aggregate_sig: AggregateSignature, + pub aggregate_signature: AggregateSignature, } impl Encodable for Attestation { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.data); - s.append(&self.participation_bitfield); + s.append(&self.aggregation_bitfield); s.append(&self.custody_bitfield); - s.append(&self.aggregate_sig); + s.append(&self.aggregate_signature); } } impl Decodable for Attestation { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (data, i) = AttestationData::ssz_decode(bytes, i)?; - let (participation_bitfield, i) = Bitfield::ssz_decode(bytes, i)?; + let (aggregation_bitfield, i) = Bitfield::ssz_decode(bytes, i)?; let (custody_bitfield, i) = Bitfield::ssz_decode(bytes, i)?; - let (aggregate_sig, i) = AggregateSignature::ssz_decode(bytes, i)?; + let (aggregate_signature, i) = AggregateSignature::ssz_decode(bytes, i)?; let attestation_record = Self { data, - participation_bitfield, + aggregation_bitfield, custody_bitfield, - aggregate_sig, + aggregate_signature, }; Ok((attestation_record, i)) } @@ -42,9 +42,9 @@ impl Attestation { pub fn zero() -> Self { Self { data: AttestationData::zero(), - participation_bitfield: Bitfield::new(), + aggregation_bitfield: Bitfield::new(), custody_bitfield: Bitfield::new(), - aggregate_sig: AggregateSignature::new(), + aggregate_signature: AggregateSignature::new(), } } } @@ -53,9 +53,9 @@ impl TestRandom for Attestation { fn random_for_test(rng: &mut T) -> Self { Self { data: <_>::random_for_test(rng), - participation_bitfield: <_>::random_for_test(rng), + aggregation_bitfield: <_>::random_for_test(rng), custody_bitfield: <_>::random_for_test(rng), - aggregate_sig: <_>::random_for_test(rng), + aggregate_signature: <_>::random_for_test(rng), } } } diff --git a/eth2/types/src/attestation_data.rs b/eth2/types/src/attestation_data.rs index e1d70e2b0..c1e895d6c 100644 --- a/eth2/types/src/attestation_data.rs +++ b/eth2/types/src/attestation_data.rs @@ -7,23 +7,23 @@ pub const SSZ_ATTESTION_DATA_LENGTH: usize = { 8 + // slot 8 + // shard 32 + // beacon_block_hash - 32 + // epoch_boundary_hash + 32 + // epoch_boundary_root 32 + // shard_block_hash 32 + // latest_crosslink_hash 8 + // justified_slot - 32 // justified_block_hash + 32 // justified_block_root }; #[derive(Debug, Clone, PartialEq, Default)] pub struct AttestationData { pub slot: u64, pub shard: u64, - pub beacon_block_hash: Hash256, - pub epoch_boundary_hash: Hash256, - pub shard_block_hash: Hash256, - pub latest_crosslink_hash: Hash256, + pub beacon_block_root: Hash256, + pub epoch_boundary_root: Hash256, + pub shard_block_root: Hash256, + pub latest_crosslink_root: Hash256, pub justified_slot: u64, - pub justified_block_hash: Hash256, + pub justified_block_root: Hash256, } impl AttestationData { @@ -31,12 +31,12 @@ impl AttestationData { Self { slot: 0, shard: 0, - beacon_block_hash: Hash256::zero(), - epoch_boundary_hash: Hash256::zero(), - shard_block_hash: Hash256::zero(), - latest_crosslink_hash: Hash256::zero(), + beacon_block_root: Hash256::zero(), + epoch_boundary_root: Hash256::zero(), + shard_block_root: Hash256::zero(), + latest_crosslink_root: Hash256::zero(), justified_slot: 0, - justified_block_hash: Hash256::zero(), + justified_block_root: Hash256::zero(), } } @@ -51,12 +51,12 @@ impl Encodable for AttestationData { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.slot); s.append(&self.shard); - s.append(&self.beacon_block_hash); - s.append(&self.epoch_boundary_hash); - s.append(&self.shard_block_hash); - s.append(&self.latest_crosslink_hash); + s.append(&self.beacon_block_root); + s.append(&self.epoch_boundary_root); + s.append(&self.shard_block_root); + s.append(&self.latest_crosslink_root); s.append(&self.justified_slot); - s.append(&self.justified_block_hash); + s.append(&self.justified_block_root); } } @@ -64,22 +64,22 @@ impl Decodable for AttestationData { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (slot, i) = u64::ssz_decode(bytes, i)?; let (shard, i) = u64::ssz_decode(bytes, i)?; - let (beacon_block_hash, i) = Hash256::ssz_decode(bytes, i)?; - let (epoch_boundary_hash, i) = Hash256::ssz_decode(bytes, i)?; - let (shard_block_hash, i) = Hash256::ssz_decode(bytes, i)?; - let (latest_crosslink_hash, i) = Hash256::ssz_decode(bytes, i)?; + let (beacon_block_root, i) = Hash256::ssz_decode(bytes, i)?; + let (epoch_boundary_root, i) = Hash256::ssz_decode(bytes, i)?; + let (shard_block_root, i) = Hash256::ssz_decode(bytes, i)?; + let (latest_crosslink_root, i) = Hash256::ssz_decode(bytes, i)?; let (justified_slot, i) = u64::ssz_decode(bytes, i)?; - let (justified_block_hash, i) = Hash256::ssz_decode(bytes, i)?; + let (justified_block_root, i) = Hash256::ssz_decode(bytes, i)?; let attestation_data = AttestationData { slot, shard, - beacon_block_hash, - epoch_boundary_hash, - shard_block_hash, - latest_crosslink_hash, + beacon_block_root, + epoch_boundary_root, + shard_block_root, + latest_crosslink_root, justified_slot, - justified_block_hash, + justified_block_root, }; Ok((attestation_data, i)) } @@ -90,12 +90,12 @@ impl TestRandom for AttestationData { Self { slot: <_>::random_for_test(rng), shard: <_>::random_for_test(rng), - beacon_block_hash: <_>::random_for_test(rng), - epoch_boundary_hash: <_>::random_for_test(rng), - shard_block_hash: <_>::random_for_test(rng), - latest_crosslink_hash: <_>::random_for_test(rng), + beacon_block_root: <_>::random_for_test(rng), + epoch_boundary_root: <_>::random_for_test(rng), + shard_block_root: <_>::random_for_test(rng), + latest_crosslink_root: <_>::random_for_test(rng), justified_slot: <_>::random_for_test(rng), - justified_block_hash: <_>::random_for_test(rng), + justified_block_root: <_>::random_for_test(rng), } } } diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs index 30a1bd83b..4dff199f3 100644 --- a/eth2/types/src/beacon_block.rs +++ b/eth2/types/src/beacon_block.rs @@ -1,5 +1,5 @@ use super::ssz::{ssz_encode, Decodable, DecodeError, Encodable, SszStream}; -use super::{BeaconBlockBody, Hash256}; +use super::{BeaconBlockBody, Eth1Data, Hash256}; use crate::test_utils::TestRandom; use bls::Signature; use hashing::canonical_hash; @@ -10,8 +10,8 @@ pub struct BeaconBlock { pub slot: u64, pub parent_root: Hash256, pub state_root: Hash256, - pub randao_reveal: Hash256, - pub candidate_pow_receipt_root: Hash256, + pub randao_reveal: Signature, + pub eth1_data: Eth1Data, pub signature: Signature, pub body: BeaconBlockBody, } @@ -30,7 +30,7 @@ impl Encodable for BeaconBlock { s.append(&self.parent_root); s.append(&self.state_root); s.append(&self.randao_reveal); - s.append(&self.candidate_pow_receipt_root); + s.append(&self.eth1_data); s.append(&self.signature); s.append(&self.body); } @@ -42,7 +42,7 @@ impl Decodable for BeaconBlock { let (parent_root, i) = <_>::ssz_decode(bytes, i)?; let (state_root, i) = <_>::ssz_decode(bytes, i)?; let (randao_reveal, i) = <_>::ssz_decode(bytes, i)?; - let (candidate_pow_receipt_root, i) = <_>::ssz_decode(bytes, i)?; + let (eth1_data, i) = <_>::ssz_decode(bytes, i)?; let (signature, i) = <_>::ssz_decode(bytes, i)?; let (body, i) = <_>::ssz_decode(bytes, i)?; @@ -52,7 +52,7 @@ impl Decodable for BeaconBlock { parent_root, state_root, randao_reveal, - candidate_pow_receipt_root, + eth1_data, signature, body, }, @@ -68,7 +68,7 @@ impl TestRandom for BeaconBlock { parent_root: <_>::random_for_test(rng), state_root: <_>::random_for_test(rng), randao_reveal: <_>::random_for_test(rng), - candidate_pow_receipt_root: <_>::random_for_test(rng), + eth1_data: <_>::random_for_test(rng), signature: <_>::random_for_test(rng), body: <_>::random_for_test(rng), } diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs index c55ce8ec9..34afeaa83 100644 --- a/eth2/types/src/beacon_state.rs +++ b/eth2/types/src/beacon_state.rs @@ -1,8 +1,9 @@ -use super::candidate_pow_receipt_root_record::CandidatePoWReceiptRootRecord; -use super::crosslink_record::CrosslinkRecord; -use super::fork_data::ForkData; -use super::pending_attestation_record::PendingAttestationRecord; -use super::validator_record::ValidatorRecord; +use super::crosslink::Crosslink; +use super::eth1_data::Eth1Data; +use super::eth1_data_vote::Eth1DataVote; +use super::fork::Fork; +use super::pending_attestation::PendingAttestation; +use super::validator::Validator; use super::Hash256; use crate::test_utils::TestRandom; use hashing::canonical_hash; @@ -17,12 +18,12 @@ pub struct BeaconState { // Misc pub slot: u64, pub genesis_time: u64, - pub fork_data: ForkData, + pub fork_data: Fork, // Validator registry - pub validator_registry: Vec, + pub validator_registry: Vec, pub validator_balances: Vec, - pub validator_registry_latest_change_slot: u64, + pub validator_registry_update_slot: u64, pub validator_registry_exit_count: u64, pub validator_registry_delta_chain_tip: Hash256, @@ -46,15 +47,15 @@ pub struct BeaconState { pub finalized_slot: u64, // Recent state - pub latest_crosslinks: Vec, + pub latest_crosslinks: Vec, pub latest_block_roots: Vec, pub latest_penalized_exit_balances: Vec, - pub latest_attestations: Vec, + pub latest_attestations: Vec, pub batched_block_roots: Vec, - // PoW receipt root (a.k.a. deposit root) - pub processed_pow_receipt_root: Hash256, - pub candidate_pow_receipt_roots: Vec, + // Ethereum 1.0 chain data + pub latest_eth1_data: Eth1Data, + pub eth1_data_votes: Vec, } impl BeaconState { @@ -72,7 +73,7 @@ impl Encodable for BeaconState { s.append(&self.fork_data); s.append(&self.validator_registry); s.append(&self.validator_balances); - s.append(&self.validator_registry_latest_change_slot); + s.append(&self.validator_registry_update_slot); s.append(&self.validator_registry_exit_count); s.append(&self.validator_registry_delta_chain_tip); s.append(&self.latest_randao_mixes); @@ -93,8 +94,8 @@ impl Encodable for BeaconState { s.append(&self.latest_penalized_exit_balances); s.append(&self.latest_attestations); s.append(&self.batched_block_roots); - s.append(&self.processed_pow_receipt_root); - s.append(&self.candidate_pow_receipt_roots); + s.append(&self.latest_eth1_data); + s.append(&self.eth1_data_votes); } } @@ -105,7 +106,7 @@ impl Decodable for BeaconState { let (fork_data, i) = <_>::ssz_decode(bytes, i)?; let (validator_registry, i) = <_>::ssz_decode(bytes, i)?; let (validator_balances, i) = <_>::ssz_decode(bytes, i)?; - let (validator_registry_latest_change_slot, i) = <_>::ssz_decode(bytes, i)?; + let (validator_registry_update_slot, i) = <_>::ssz_decode(bytes, i)?; let (validator_registry_exit_count, i) = <_>::ssz_decode(bytes, i)?; let (validator_registry_delta_chain_tip, i) = <_>::ssz_decode(bytes, i)?; let (latest_randao_mixes, i) = <_>::ssz_decode(bytes, i)?; @@ -126,8 +127,8 @@ impl Decodable for BeaconState { let (latest_penalized_exit_balances, i) = <_>::ssz_decode(bytes, i)?; let (latest_attestations, i) = <_>::ssz_decode(bytes, i)?; let (batched_block_roots, i) = <_>::ssz_decode(bytes, i)?; - let (processed_pow_receipt_root, i) = <_>::ssz_decode(bytes, i)?; - let (candidate_pow_receipt_roots, i) = <_>::ssz_decode(bytes, i)?; + let (latest_eth1_data, i) = <_>::ssz_decode(bytes, i)?; + let (eth1_data_votes, i) = <_>::ssz_decode(bytes, i)?; Ok(( Self { @@ -136,7 +137,7 @@ impl Decodable for BeaconState { fork_data, validator_registry, validator_balances, - validator_registry_latest_change_slot, + validator_registry_update_slot, validator_registry_exit_count, validator_registry_delta_chain_tip, latest_randao_mixes, @@ -157,8 +158,8 @@ impl Decodable for BeaconState { latest_penalized_exit_balances, latest_attestations, batched_block_roots, - processed_pow_receipt_root, - candidate_pow_receipt_roots, + latest_eth1_data, + eth1_data_votes, }, i, )) @@ -173,7 +174,7 @@ impl TestRandom for BeaconState { fork_data: <_>::random_for_test(rng), validator_registry: <_>::random_for_test(rng), validator_balances: <_>::random_for_test(rng), - validator_registry_latest_change_slot: <_>::random_for_test(rng), + validator_registry_update_slot: <_>::random_for_test(rng), validator_registry_exit_count: <_>::random_for_test(rng), validator_registry_delta_chain_tip: <_>::random_for_test(rng), latest_randao_mixes: <_>::random_for_test(rng), @@ -194,8 +195,8 @@ impl TestRandom for BeaconState { latest_penalized_exit_balances: <_>::random_for_test(rng), latest_attestations: <_>::random_for_test(rng), batched_block_roots: <_>::random_for_test(rng), - processed_pow_receipt_root: <_>::random_for_test(rng), - candidate_pow_receipt_roots: <_>::random_for_test(rng), + latest_eth1_data: <_>::random_for_test(rng), + eth1_data_votes: <_>::random_for_test(rng), } } } diff --git a/eth2/types/src/crosslink_record.rs b/eth2/types/src/crosslink.rs similarity index 85% rename from eth2/types/src/crosslink_record.rs rename to eth2/types/src/crosslink.rs index ae6c5bf92..69f94662a 100644 --- a/eth2/types/src/crosslink_record.rs +++ b/eth2/types/src/crosslink.rs @@ -4,12 +4,12 @@ use crate::test_utils::TestRandom; use rand::RngCore; #[derive(Clone, Debug, PartialEq)] -pub struct CrosslinkRecord { +pub struct Crosslink { pub slot: u64, pub shard_block_root: Hash256, } -impl CrosslinkRecord { +impl Crosslink { /// Generates a new instance where `dynasty` and `hash` are both zero. pub fn zero() -> Self { Self { @@ -19,14 +19,14 @@ impl CrosslinkRecord { } } -impl Encodable for CrosslinkRecord { +impl Encodable for Crosslink { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.slot); s.append(&self.shard_block_root); } } -impl Decodable for CrosslinkRecord { +impl Decodable for Crosslink { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (slot, i) = <_>::ssz_decode(bytes, i)?; let (shard_block_root, i) = <_>::ssz_decode(bytes, i)?; @@ -41,7 +41,7 @@ impl Decodable for CrosslinkRecord { } } -impl TestRandom for CrosslinkRecord { +impl TestRandom for Crosslink { fn random_for_test(rng: &mut T) -> Self { Self { slot: <_>::random_for_test(rng), @@ -59,7 +59,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let mut rng = XorShiftRng::from_seed([42; 16]); - let original = CrosslinkRecord::random_for_test(&mut rng); + let original = Crosslink::random_for_test(&mut rng); let bytes = ssz_encode(&original); let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); diff --git a/eth2/types/src/deposit_data.rs b/eth2/types/src/deposit_data.rs index 5dcd20c7c..b85a95708 100644 --- a/eth2/types/src/deposit_data.rs +++ b/eth2/types/src/deposit_data.rs @@ -5,30 +5,30 @@ use rand::RngCore; #[derive(Debug, PartialEq, Clone)] pub struct DepositData { - pub deposit_input: DepositInput, - pub value: u64, + pub amount: u64, pub timestamp: u64, + pub deposit_input: DepositInput, } impl Encodable for DepositData { fn ssz_append(&self, s: &mut SszStream) { - s.append(&self.deposit_input); - s.append(&self.value); + s.append(&self.amount); s.append(&self.timestamp); + s.append(&self.deposit_input); } } impl Decodable for DepositData { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { - let (deposit_input, i) = <_>::ssz_decode(bytes, i)?; - let (value, i) = <_>::ssz_decode(bytes, i)?; + let (amount, i) = <_>::ssz_decode(bytes, i)?; let (timestamp, i) = <_>::ssz_decode(bytes, i)?; + let (deposit_input, i) = <_>::ssz_decode(bytes, i)?; Ok(( Self { - deposit_input, - value, + amount, timestamp, + deposit_input, }, i, )) @@ -38,9 +38,9 @@ impl Decodable for DepositData { impl TestRandom for DepositData { fn random_for_test(rng: &mut T) -> Self { Self { - deposit_input: <_>::random_for_test(rng), - value: <_>::random_for_test(rng), + amount: <_>::random_for_test(rng), timestamp: <_>::random_for_test(rng), + deposit_input: <_>::random_for_test(rng), } } } diff --git a/eth2/types/src/deposit_input.rs b/eth2/types/src/deposit_input.rs index 7a2bfa3c9..4f2d71096 100644 --- a/eth2/types/src/deposit_input.rs +++ b/eth2/types/src/deposit_input.rs @@ -8,8 +8,6 @@ use rand::RngCore; pub struct DepositInput { pub pubkey: PublicKey, pub withdrawal_credentials: Hash256, - pub randao_commitment: Hash256, - pub custody_commitment: Hash256, pub proof_of_possession: Signature, } @@ -17,8 +15,6 @@ impl Encodable for DepositInput { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.pubkey); s.append(&self.withdrawal_credentials); - s.append(&self.randao_commitment); - s.append(&self.custody_commitment); s.append(&self.proof_of_possession); } } @@ -27,16 +23,12 @@ impl Decodable for DepositInput { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (pubkey, i) = <_>::ssz_decode(bytes, i)?; let (withdrawal_credentials, i) = <_>::ssz_decode(bytes, i)?; - let (randao_commitment, i) = <_>::ssz_decode(bytes, i)?; - let (custody_commitment, i) = <_>::ssz_decode(bytes, i)?; let (proof_of_possession, i) = <_>::ssz_decode(bytes, i)?; Ok(( Self { pubkey, withdrawal_credentials, - randao_commitment, - custody_commitment, proof_of_possession, }, i, @@ -49,8 +41,6 @@ impl TestRandom for DepositInput { Self { pubkey: <_>::random_for_test(rng), withdrawal_credentials: <_>::random_for_test(rng), - randao_commitment: <_>::random_for_test(rng), - custody_commitment: <_>::random_for_test(rng), proof_of_possession: <_>::random_for_test(rng), } } diff --git a/eth2/types/src/candidate_pow_receipt_root_record.rs b/eth2/types/src/eth1_data.rs similarity index 53% rename from eth2/types/src/candidate_pow_receipt_root_record.rs rename to eth2/types/src/eth1_data.rs index 9648763f3..a20559e18 100644 --- a/eth2/types/src/candidate_pow_receipt_root_record.rs +++ b/eth2/types/src/eth1_data.rs @@ -4,39 +4,39 @@ use crate::test_utils::TestRandom; use rand::RngCore; // Note: this is refer to as DepositRootVote in specs -#[derive(Debug, PartialEq, Clone)] -pub struct CandidatePoWReceiptRootRecord { - pub candidate_pow_receipt_root: Hash256, - pub votes: u64, +#[derive(Debug, PartialEq, Clone, Default)] +pub struct Eth1Data { + pub deposit_root: Hash256, + pub block_hash: Hash256, } -impl Encodable for CandidatePoWReceiptRootRecord { +impl Encodable for Eth1Data { fn ssz_append(&self, s: &mut SszStream) { - s.append(&self.candidate_pow_receipt_root); - s.append(&self.votes); + s.append(&self.deposit_root); + s.append(&self.block_hash); } } -impl Decodable for CandidatePoWReceiptRootRecord { +impl Decodable for Eth1Data { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { - let (candidate_pow_receipt_root, i) = <_>::ssz_decode(bytes, i)?; - let (votes, i) = <_>::ssz_decode(bytes, i)?; + let (deposit_root, i) = <_>::ssz_decode(bytes, i)?; + let (block_hash, i) = <_>::ssz_decode(bytes, i)?; Ok(( Self { - candidate_pow_receipt_root, - votes, + deposit_root, + block_hash, }, i, )) } } -impl TestRandom for CandidatePoWReceiptRootRecord { +impl TestRandom for Eth1Data { fn random_for_test(rng: &mut T) -> Self { Self { - candidate_pow_receipt_root: <_>::random_for_test(rng), - votes: <_>::random_for_test(rng), + deposit_root: <_>::random_for_test(rng), + block_hash: <_>::random_for_test(rng), } } } @@ -50,7 +50,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let mut rng = XorShiftRng::from_seed([42; 16]); - let original = CandidatePoWReceiptRootRecord::random_for_test(&mut rng); + let original = Eth1Data::random_for_test(&mut rng); let bytes = ssz_encode(&original); let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); diff --git a/eth2/types/src/eth1_data_vote.rs b/eth2/types/src/eth1_data_vote.rs new file mode 100644 index 000000000..c4d9d01af --- /dev/null +++ b/eth2/types/src/eth1_data_vote.rs @@ -0,0 +1,60 @@ +use super::ssz::{Decodable, DecodeError, Encodable, SszStream}; +use super::Eth1Data; +use crate::test_utils::TestRandom; +use rand::RngCore; + +// Note: this is refer to as DepositRootVote in specs +#[derive(Debug, PartialEq, Clone, Default)] +pub struct Eth1DataVote { + pub eth1_data: Eth1Data, + pub vote_count: u64, +} + +impl Encodable for Eth1DataVote { + fn ssz_append(&self, s: &mut SszStream) { + s.append(&self.eth1_data); + s.append(&self.vote_count); + } +} + +impl Decodable for Eth1DataVote { + fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { + let (eth1_data, i) = <_>::ssz_decode(bytes, i)?; + let (vote_count, i) = <_>::ssz_decode(bytes, i)?; + + Ok(( + Self { + eth1_data, + vote_count, + }, + i, + )) + } +} + +impl TestRandom for Eth1DataVote { + fn random_for_test(rng: &mut T) -> Self { + Self { + eth1_data: <_>::random_for_test(rng), + vote_count: <_>::random_for_test(rng), + } + } +} + +#[cfg(test)] +mod tests { + use super::super::ssz::ssz_encode; + use super::*; + use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng}; + + #[test] + pub fn test_ssz_round_trip() { + let mut rng = XorShiftRng::from_seed([42; 16]); + let original = Eth1DataVote::random_for_test(&mut rng); + + let bytes = ssz_encode(&original); + let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); + + assert_eq!(original, decoded); + } +} diff --git a/eth2/types/src/fork_data.rs b/eth2/types/src/fork.rs similarity index 89% rename from eth2/types/src/fork_data.rs rename to eth2/types/src/fork.rs index a66502584..b70dafccc 100644 --- a/eth2/types/src/fork_data.rs +++ b/eth2/types/src/fork.rs @@ -3,13 +3,13 @@ use crate::test_utils::TestRandom; use rand::RngCore; #[derive(Debug, Clone, PartialEq, Default)] -pub struct ForkData { +pub struct Fork { pub pre_fork_version: u64, pub post_fork_version: u64, pub fork_slot: u64, } -impl Encodable for ForkData { +impl Encodable for Fork { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.pre_fork_version); s.append(&self.post_fork_version); @@ -17,7 +17,7 @@ impl Encodable for ForkData { } } -impl Decodable for ForkData { +impl Decodable for Fork { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (pre_fork_version, i) = <_>::ssz_decode(bytes, i)?; let (post_fork_version, i) = <_>::ssz_decode(bytes, i)?; @@ -34,7 +34,7 @@ impl Decodable for ForkData { } } -impl TestRandom for ForkData { +impl TestRandom for Fork { fn random_for_test(rng: &mut T) -> Self { Self { pre_fork_version: <_>::random_for_test(rng), @@ -53,7 +53,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let mut rng = XorShiftRng::from_seed([42; 16]); - let original = ForkData::random_for_test(&mut rng); + let original = Fork::random_for_test(&mut rng); let bytes = ssz_encode(&original); let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); diff --git a/eth2/types/src/lib.rs b/eth2/types/src/lib.rs index f00c19d03..6c4a1b977 100644 --- a/eth2/types/src/lib.rs +++ b/eth2/types/src/lib.rs @@ -10,23 +10,25 @@ pub mod attestation_data; pub mod beacon_block; pub mod beacon_block_body; pub mod beacon_state; -pub mod candidate_pow_receipt_root_record; pub mod casper_slashing; -pub mod crosslink_record; +pub mod crosslink; pub mod deposit; pub mod deposit_data; pub mod deposit_input; +pub mod eth1_data; +pub mod eth1_data_vote; pub mod exit; -pub mod fork_data; -pub mod pending_attestation_record; +pub mod fork; +pub mod pending_attestation; pub mod proposal_signed_data; pub mod proposer_slashing; pub mod shard_committee; pub mod shard_reassignment_record; pub mod slashable_vote_data; pub mod special_record; -pub mod validator_record; +pub mod validator; pub mod validator_registry; +pub mod validator_registry_delta_block; pub mod readers; @@ -39,19 +41,22 @@ pub use crate::beacon_block::BeaconBlock; pub use crate::beacon_block_body::BeaconBlockBody; pub use crate::beacon_state::BeaconState; pub use crate::casper_slashing::CasperSlashing; -pub use crate::crosslink_record::CrosslinkRecord; +pub use crate::crosslink::Crosslink; pub use crate::deposit::Deposit; pub use crate::deposit_data::DepositData; pub use crate::deposit_input::DepositInput; +pub use crate::eth1_data::Eth1Data; +pub use crate::eth1_data_vote::Eth1DataVote; pub use crate::exit::Exit; -pub use crate::fork_data::ForkData; -pub use crate::pending_attestation_record::PendingAttestationRecord; +pub use crate::fork::Fork; +pub use crate::pending_attestation::PendingAttestation; pub use crate::proposal_signed_data::ProposalSignedData; pub use crate::proposer_slashing::ProposerSlashing; pub use crate::shard_committee::ShardCommittee; pub use crate::slashable_vote_data::SlashableVoteData; pub use crate::special_record::{SpecialRecord, SpecialRecordKind}; -pub use crate::validator_record::{StatusFlags as ValidatorStatusFlags, ValidatorRecord}; +pub use crate::validator::{StatusFlags as ValidatorStatusFlags, Validator}; +pub use crate::validator_registry_delta_block::ValidatorRegistryDeltaBlock; pub type Hash256 = H256; pub type Address = H160; diff --git a/eth2/types/src/pending_attestation_record.rs b/eth2/types/src/pending_attestation.rs similarity index 74% rename from eth2/types/src/pending_attestation_record.rs rename to eth2/types/src/pending_attestation.rs index 3bebf5676..ad3dbb782 100644 --- a/eth2/types/src/pending_attestation_record.rs +++ b/eth2/types/src/pending_attestation.rs @@ -4,33 +4,33 @@ use crate::test_utils::TestRandom; use rand::RngCore; #[derive(Debug, Clone, PartialEq)] -pub struct PendingAttestationRecord { +pub struct PendingAttestation { pub data: AttestationData, - pub participation_bitfield: Bitfield, + pub aggregation_bitfield: Bitfield, pub custody_bitfield: Bitfield, pub slot_included: u64, } -impl Encodable for PendingAttestationRecord { +impl Encodable for PendingAttestation { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.data); - s.append(&self.participation_bitfield); + s.append(&self.aggregation_bitfield); s.append(&self.custody_bitfield); s.append(&self.slot_included); } } -impl Decodable for PendingAttestationRecord { +impl Decodable for PendingAttestation { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (data, i) = <_>::ssz_decode(bytes, i)?; - let (participation_bitfield, i) = <_>::ssz_decode(bytes, i)?; + let (aggregation_bitfield, i) = <_>::ssz_decode(bytes, i)?; let (custody_bitfield, i) = <_>::ssz_decode(bytes, i)?; let (slot_included, i) = <_>::ssz_decode(bytes, i)?; Ok(( Self { data, - participation_bitfield, + aggregation_bitfield, custody_bitfield, slot_included, }, @@ -39,11 +39,11 @@ impl Decodable for PendingAttestationRecord { } } -impl TestRandom for PendingAttestationRecord { +impl TestRandom for PendingAttestation { fn random_for_test(rng: &mut T) -> Self { Self { data: <_>::random_for_test(rng), - participation_bitfield: <_>::random_for_test(rng), + aggregation_bitfield: <_>::random_for_test(rng), custody_bitfield: <_>::random_for_test(rng), slot_included: <_>::random_for_test(rng), } @@ -59,7 +59,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let mut rng = XorShiftRng::from_seed([42; 16]); - let original = PendingAttestationRecord::random_for_test(&mut rng); + let original = PendingAttestation::random_for_test(&mut rng); let bytes = ssz_encode(&original); let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); diff --git a/eth2/types/src/slashable_vote_data.rs b/eth2/types/src/slashable_vote_data.rs index 5703853b2..e6fa36bc1 100644 --- a/eth2/types/src/slashable_vote_data.rs +++ b/eth2/types/src/slashable_vote_data.rs @@ -6,16 +6,16 @@ use rand::RngCore; #[derive(Debug, PartialEq, Clone)] pub struct SlashableVoteData { - pub aggregate_signature_poc_0_indices: Vec, - pub aggregate_signature_poc_1_indices: Vec, + pub custody_bit_0_indices: Vec, + pub custody_bit_1_indices: Vec, pub data: AttestationData, pub aggregate_signature: AggregateSignature, } impl Encodable for SlashableVoteData { fn ssz_append(&self, s: &mut SszStream) { - s.append_vec(&self.aggregate_signature_poc_0_indices); - s.append_vec(&self.aggregate_signature_poc_1_indices); + s.append_vec(&self.custody_bit_0_indices); + s.append_vec(&self.custody_bit_1_indices); s.append(&self.data); s.append(&self.aggregate_signature); } @@ -23,15 +23,15 @@ impl Encodable for SlashableVoteData { impl Decodable for SlashableVoteData { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { - let (aggregate_signature_poc_0_indices, i) = <_>::ssz_decode(bytes, i)?; - let (aggregate_signature_poc_1_indices, i) = <_>::ssz_decode(bytes, i)?; + let (custody_bit_0_indices, i) = <_>::ssz_decode(bytes, i)?; + let (custody_bit_1_indices, i) = <_>::ssz_decode(bytes, i)?; let (data, i) = <_>::ssz_decode(bytes, i)?; let (aggregate_signature, i) = <_>::ssz_decode(bytes, i)?; Ok(( SlashableVoteData { - aggregate_signature_poc_0_indices, - aggregate_signature_poc_1_indices, + custody_bit_0_indices, + custody_bit_1_indices, data, aggregate_signature, }, @@ -43,8 +43,8 @@ impl Decodable for SlashableVoteData { impl TestRandom for SlashableVoteData { fn random_for_test(rng: &mut T) -> Self { Self { - aggregate_signature_poc_0_indices: <_>::random_for_test(rng), - aggregate_signature_poc_1_indices: <_>::random_for_test(rng), + custody_bit_0_indices: <_>::random_for_test(rng), + custody_bit_1_indices: <_>::random_for_test(rng), data: <_>::random_for_test(rng), aggregate_signature: <_>::random_for_test(rng), } diff --git a/eth2/types/src/validator_record.rs b/eth2/types/src/validator.rs similarity index 82% rename from eth2/types/src/validator_record.rs rename to eth2/types/src/validator.rs index 5a8cde8ab..8408e7423 100644 --- a/eth2/types/src/validator_record.rs +++ b/eth2/types/src/validator.rs @@ -21,7 +21,7 @@ impl From for DecodeError { } } -/// Handles the serialization logic for the `status_flags` field of the `ValidatorRecord`. +/// Handles the serialization logic for the `status_flags` field of the `Validator`. fn status_flag_to_byte(flag: Option) -> u8 { if let Some(flag) = flag { match flag { @@ -33,7 +33,7 @@ fn status_flag_to_byte(flag: Option) -> u8 { } } -/// Handles the deserialization logic for the `status_flags` field of the `ValidatorRecord`. +/// Handles the deserialization logic for the `status_flags` field of the `Validator`. fn status_flag_from_byte(flag: u8) -> Result, StatusFlagsDecodeError> { match flag { 0 => Ok(None), @@ -44,44 +44,40 @@ fn status_flag_from_byte(flag: u8) -> Result, StatusFlagsDec } #[derive(Debug, Clone, PartialEq)] -pub struct ValidatorRecord { +pub struct Validator { pub pubkey: PublicKey, pub withdrawal_credentials: Hash256, - pub randao_commitment: Hash256, - pub randao_layers: u64, + pub proposer_slots: u64, pub activation_slot: u64, pub exit_slot: u64, pub withdrawal_slot: u64, pub penalized_slot: u64, pub exit_count: u64, pub status_flags: Option, - pub custody_commitment: Hash256, pub latest_custody_reseed_slot: u64, pub penultimate_custody_reseed_slot: u64, } -impl ValidatorRecord { +impl Validator { /// This predicate indicates if the validator represented by this record is considered "active" at `slot`. pub fn is_active_at(&self, slot: u64) -> bool { self.activation_slot <= slot && slot < self.exit_slot } } -impl Default for ValidatorRecord { - /// Yields a "default" `ValidatorRecord`. Primarily used for testing. +impl Default for Validator { + /// Yields a "default" `Validator`. Primarily used for testing. fn default() -> Self { Self { pubkey: PublicKey::default(), withdrawal_credentials: Hash256::default(), - randao_commitment: Hash256::default(), - randao_layers: 0, + proposer_slots: 0, activation_slot: std::u64::MAX, exit_slot: std::u64::MAX, withdrawal_slot: std::u64::MAX, penalized_slot: std::u64::MAX, exit_count: 0, status_flags: None, - custody_commitment: Hash256::default(), latest_custody_reseed_slot: 0, // NOTE: is `GENESIS_SLOT` penultimate_custody_reseed_slot: 0, // NOTE: is `GENESIS_SLOT` } @@ -95,37 +91,33 @@ impl TestRandom for StatusFlags { } } -impl Encodable for ValidatorRecord { +impl Encodable for Validator { fn ssz_append(&self, s: &mut SszStream) { s.append(&self.pubkey); s.append(&self.withdrawal_credentials); - s.append(&self.randao_commitment); - s.append(&self.randao_layers); + s.append(&self.proposer_slots); s.append(&self.activation_slot); s.append(&self.exit_slot); s.append(&self.withdrawal_slot); s.append(&self.penalized_slot); s.append(&self.exit_count); s.append(&status_flag_to_byte(self.status_flags)); - s.append(&self.custody_commitment); s.append(&self.latest_custody_reseed_slot); s.append(&self.penultimate_custody_reseed_slot); } } -impl Decodable for ValidatorRecord { +impl Decodable for Validator { fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { let (pubkey, i) = <_>::ssz_decode(bytes, i)?; let (withdrawal_credentials, i) = <_>::ssz_decode(bytes, i)?; - let (randao_commitment, i) = <_>::ssz_decode(bytes, i)?; - let (randao_layers, i) = <_>::ssz_decode(bytes, i)?; + let (proposer_slots, i) = <_>::ssz_decode(bytes, i)?; let (activation_slot, i) = <_>::ssz_decode(bytes, i)?; let (exit_slot, i) = <_>::ssz_decode(bytes, i)?; let (withdrawal_slot, i) = <_>::ssz_decode(bytes, i)?; let (penalized_slot, i) = <_>::ssz_decode(bytes, i)?; let (exit_count, i) = <_>::ssz_decode(bytes, i)?; let (status_flags_byte, i): (u8, usize) = <_>::ssz_decode(bytes, i)?; - let (custody_commitment, i) = <_>::ssz_decode(bytes, i)?; let (latest_custody_reseed_slot, i) = <_>::ssz_decode(bytes, i)?; let (penultimate_custody_reseed_slot, i) = <_>::ssz_decode(bytes, i)?; @@ -135,15 +127,13 @@ impl Decodable for ValidatorRecord { Self { pubkey, withdrawal_credentials, - randao_commitment, - randao_layers, + proposer_slots, activation_slot, exit_slot, withdrawal_slot, penalized_slot, exit_count, status_flags, - custody_commitment, latest_custody_reseed_slot, penultimate_custody_reseed_slot, }, @@ -152,20 +142,18 @@ impl Decodable for ValidatorRecord { } } -impl TestRandom for ValidatorRecord { +impl TestRandom for Validator { fn random_for_test(rng: &mut T) -> Self { Self { pubkey: <_>::random_for_test(rng), withdrawal_credentials: <_>::random_for_test(rng), - randao_commitment: <_>::random_for_test(rng), - randao_layers: <_>::random_for_test(rng), + proposer_slots: <_>::random_for_test(rng), activation_slot: <_>::random_for_test(rng), exit_slot: <_>::random_for_test(rng), withdrawal_slot: <_>::random_for_test(rng), penalized_slot: <_>::random_for_test(rng), exit_count: <_>::random_for_test(rng), status_flags: Some(<_>::random_for_test(rng)), - custody_commitment: <_>::random_for_test(rng), latest_custody_reseed_slot: <_>::random_for_test(rng), penultimate_custody_reseed_slot: <_>::random_for_test(rng), } @@ -181,7 +169,7 @@ mod tests { #[test] pub fn test_ssz_round_trip() { let mut rng = XorShiftRng::from_seed([42; 16]); - let original = ValidatorRecord::random_for_test(&mut rng); + let original = Validator::random_for_test(&mut rng); let bytes = ssz_encode(&original); let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); @@ -192,7 +180,7 @@ mod tests { #[test] fn test_validator_can_be_active() { let mut rng = XorShiftRng::from_seed([42; 16]); - let mut validator = ValidatorRecord::random_for_test(&mut rng); + let mut validator = Validator::random_for_test(&mut rng); let activation_slot = u64::random_for_test(&mut rng); let exit_slot = activation_slot + 234; diff --git a/eth2/types/src/validator_registration.rs b/eth2/types/src/validator_registration.rs deleted file mode 100644 index 964b80b8a..000000000 --- a/eth2/types/src/validator_registration.rs +++ /dev/null @@ -1,12 +0,0 @@ -use super::{Address, Hash256}; -use bls::{PublicKey, Signature}; - -/// The information gathered from the PoW chain validator registration function. -#[derive(Debug, Clone, PartialEq)] -pub struct ValidatorRegistration { - pub pubkey: PublicKey, - pub withdrawal_shard: u64, - pub withdrawal_address: Address, - pub randao_commitment: Hash256, - pub proof_of_possession: Signature, -} diff --git a/eth2/types/src/validator_registry.rs b/eth2/types/src/validator_registry.rs index abb2e6b3f..509ab7c7b 100644 --- a/eth2/types/src/validator_registry.rs +++ b/eth2/types/src/validator_registry.rs @@ -1,9 +1,9 @@ -/// Contains logic to manipulate a `&[ValidatorRecord]`. +/// Contains logic to manipulate a `&[Validator]`. /// For now, we avoid defining a newtype and just have flat functions here. -use super::validator_record::*; +use super::validator::*; /// Given an indexed sequence of `validators`, return the indices corresponding to validators that are active at `slot`. -pub fn get_active_validator_indices(validators: &[ValidatorRecord], slot: u64) -> Vec { +pub fn get_active_validator_indices(validators: &[Validator], slot: u64) -> Vec { validators .iter() .enumerate() @@ -38,7 +38,7 @@ mod tests { let mut validators = vec![]; let count_validators = 10; for _ in 0..count_validators { - validators.push(ValidatorRecord::default()) + validators.push(Validator::default()) } let some_slot = u64::random_for_test(&mut rng); @@ -55,7 +55,7 @@ mod tests { let mut validators = (0..count_validators) .into_iter() .map(|_| { - let mut validator = ValidatorRecord::default(); + let mut validator = Validator::default(); let activation_offset = u64::random_for_test(&mut rng); let exit_offset = u64::random_for_test(&mut rng); @@ -79,7 +79,7 @@ mod tests { ); } - fn set_validators_to_default_entry_exit(validators: &mut [ValidatorRecord]) { + fn set_validators_to_default_entry_exit(validators: &mut [Validator]) { for validator in validators.iter_mut() { validator.activation_slot = std::u64::MAX; validator.exit_slot = std::u64::MAX; @@ -87,7 +87,7 @@ mod tests { } // sets all `validators` to be active as of some slot prior to `slot`. returns the activation slot. - fn set_validators_to_activated(validators: &mut [ValidatorRecord], slot: u64) -> u64 { + fn set_validators_to_activated(validators: &mut [Validator], slot: u64) -> u64 { let activation_slot = slot - 10; for validator in validators.iter_mut() { validator.activation_slot = activation_slot; @@ -96,11 +96,7 @@ mod tests { } // sets all `validators` to be exited as of some slot before `slot`. - fn set_validators_to_exited( - validators: &mut [ValidatorRecord], - slot: u64, - activation_slot: u64, - ) { + fn set_validators_to_exited(validators: &mut [Validator], slot: u64, activation_slot: u64) { assert!(activation_slot < slot); let mut exit_slot = activation_slot + 10; while exit_slot >= slot { @@ -123,7 +119,7 @@ mod tests { let mut validators = (0..COUNT_VALIDATORS) .into_iter() .map(|_| { - let mut validator = ValidatorRecord::default(); + let mut validator = Validator::default(); let activation_offset = u64::random_for_test(&mut rng); let exit_offset = u64::random_for_test(&mut rng); diff --git a/eth2/types/src/validator_registry_delta_block.rs b/eth2/types/src/validator_registry_delta_block.rs new file mode 100644 index 000000000..57aa469df --- /dev/null +++ b/eth2/types/src/validator_registry_delta_block.rs @@ -0,0 +1,89 @@ +use super::Hash256; +use crate::test_utils::TestRandom; +use bls::PublicKey; +use rand::RngCore; +use ssz::{Decodable, DecodeError, Encodable, SszStream}; + +// The information gathered from the PoW chain validator registration function. +#[derive(Debug, Clone, PartialEq)] +pub struct ValidatorRegistryDeltaBlock { + pub latest_registry_delta_root: Hash256, + pub validator_index: u32, + pub pubkey: PublicKey, + pub slot: u64, + pub flag: u64, +} + +impl Default for ValidatorRegistryDeltaBlock { + /// Yields a "default" `Validator`. Primarily used for testing. + fn default() -> Self { + Self { + latest_registry_delta_root: Hash256::zero(), + validator_index: std::u32::MAX, + pubkey: PublicKey::default(), + slot: std::u64::MAX, + flag: std::u64::MAX, + } + } +} + +impl Encodable for ValidatorRegistryDeltaBlock { + fn ssz_append(&self, s: &mut SszStream) { + s.append(&self.latest_registry_delta_root); + s.append(&self.validator_index); + s.append(&self.pubkey); + s.append(&self.slot); + s.append(&self.flag); + } +} + +impl Decodable for ValidatorRegistryDeltaBlock { + fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { + let (latest_registry_delta_root, i) = <_>::ssz_decode(bytes, i)?; + let (validator_index, i) = <_>::ssz_decode(bytes, i)?; + let (pubkey, i) = <_>::ssz_decode(bytes, i)?; + let (slot, i) = <_>::ssz_decode(bytes, i)?; + let (flag, i) = <_>::ssz_decode(bytes, i)?; + + Ok(( + Self { + latest_registry_delta_root, + validator_index, + pubkey, + slot, + flag, + }, + i, + )) + } +} + +impl TestRandom for ValidatorRegistryDeltaBlock { + fn random_for_test(rng: &mut T) -> Self { + Self { + latest_registry_delta_root: <_>::random_for_test(rng), + validator_index: <_>::random_for_test(rng), + pubkey: <_>::random_for_test(rng), + slot: <_>::random_for_test(rng), + flag: <_>::random_for_test(rng), + } + } +} + +#[cfg(test)] +mod tests { + use super::super::ssz::ssz_encode; + use super::*; + use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng}; + + #[test] + pub fn test_ssz_round_trip() { + let mut rng = XorShiftRng::from_seed([42; 16]); + let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng); + + let bytes = ssz_encode(&original); + let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap(); + + assert_eq!(original, decoded); + } +} diff --git a/eth2/validator_induction/src/inductor.rs b/eth2/validator_induction/src/inductor.rs index 9dd5089ba..6efc9af2e 100644 --- a/eth2/validator_induction/src/inductor.rs +++ b/eth2/validator_induction/src/inductor.rs @@ -1,6 +1,6 @@ use bls::verify_proof_of_possession; use spec::ChainSpec; -use types::{BeaconState, Deposit, ValidatorRecord}; +use types::{BeaconState, Deposit, Validator}; #[derive(Debug, PartialEq, Clone)] pub enum ValidatorInductionError { @@ -32,32 +32,30 @@ pub fn process_deposit( if state.validator_registry[i].withdrawal_credentials == deposit_input.withdrawal_credentials { - state.validator_balances[i] += deposit_data.value; + state.validator_balances[i] += deposit_data.amount; return Ok(()); } Err(ValidatorInductionError::InvalidWithdrawalCredentials) } None => { - let validator = ValidatorRecord { + let validator = Validator { pubkey: deposit_input.pubkey.clone(), withdrawal_credentials: deposit_input.withdrawal_credentials, - randao_commitment: deposit_input.randao_commitment, - randao_layers: 0, + proposer_slots: 0, activation_slot: spec.far_future_slot, exit_slot: spec.far_future_slot, withdrawal_slot: spec.far_future_slot, penalized_slot: spec.far_future_slot, exit_count: 0, status_flags: None, - custody_commitment: deposit_input.custody_commitment, latest_custody_reseed_slot: 0, penultimate_custody_reseed_slot: 0, }; let _index = state.validator_registry.len(); state.validator_registry.push(validator); - state.validator_balances.push(deposit_data.value); + state.validator_balances.push(deposit_data.amount); Ok(()) } } @@ -83,15 +81,14 @@ mod tests { deposit } - fn get_validator() -> ValidatorRecord { + fn get_validator() -> Validator { let mut rng = XorShiftRng::from_seed([42; 16]); - ValidatorRecord::random_for_test(&mut rng) + Validator::random_for_test(&mut rng) } - fn deposit_equals_record(dep: &Deposit, val: &ValidatorRecord) -> bool { + fn deposit_equals_record(dep: &Deposit, val: &Validator) -> bool { (dep.deposit_data.deposit_input.pubkey == val.pubkey) & (dep.deposit_data.deposit_input.withdrawal_credentials == val.withdrawal_credentials) - & (dep.deposit_data.deposit_input.randao_commitment == val.randao_commitment) & (verify_proof_of_possession( &dep.deposit_data.deposit_input.proof_of_possession, &val.pubkey, @@ -103,7 +100,7 @@ mod tests { let mut state = BeaconState::default(); let mut deposit = get_deposit(); let spec = ChainSpec::foundation(); - deposit.deposit_data.value = DEPOSIT_GWEI; + deposit.deposit_data.amount = DEPOSIT_GWEI; let result = process_deposit(&mut state, &deposit, &spec); @@ -124,7 +121,7 @@ mod tests { for i in 0..5 { let mut deposit = get_deposit(); let result = process_deposit(&mut state, &deposit, &spec); - deposit.deposit_data.value = DEPOSIT_GWEI; + deposit.deposit_data.amount = DEPOSIT_GWEI; assert_eq!(result.unwrap(), ()); assert!(deposit_equals_record( &deposit, @@ -143,11 +140,10 @@ mod tests { let mut deposit = get_deposit(); let mut validator = get_validator(); - deposit.deposit_data.value = DEPOSIT_GWEI; + deposit.deposit_data.amount = DEPOSIT_GWEI; validator.pubkey = deposit.deposit_data.deposit_input.pubkey.clone(); validator.withdrawal_credentials = deposit.deposit_data.deposit_input.withdrawal_credentials; - validator.randao_commitment = deposit.deposit_data.deposit_input.randao_commitment; state.validator_registry.push(validator); state.validator_balances.push(DEPOSIT_GWEI); @@ -169,7 +165,7 @@ mod tests { let mut state = BeaconState::default(); let mut deposit = get_deposit(); let spec = ChainSpec::foundation(); - deposit.deposit_data.value = DEPOSIT_GWEI; + deposit.deposit_data.amount = DEPOSIT_GWEI; deposit.deposit_data.deposit_input.proof_of_possession = create_proof_of_possession(&Keypair::random()); diff --git a/eth2/validator_shuffling/src/shuffle.rs b/eth2/validator_shuffling/src/shuffle.rs index 13bdf97fe..734f5995c 100644 --- a/eth2/validator_shuffling/src/shuffle.rs +++ b/eth2/validator_shuffling/src/shuffle.rs @@ -3,7 +3,7 @@ use std::cmp::min; use honey_badger_split::SplitExt; use spec::ChainSpec; use types::validator_registry::get_active_validator_indices; -use types::{ShardCommittee, ValidatorRecord}; +use types::{ShardCommittee, Validator}; use vec_shuffle::{shuffle, ShuffleErr}; type DelegatedCycle = Vec>; @@ -20,7 +20,7 @@ pub enum ValidatorAssignmentError { /// References get_new_shuffling (ethereum 2.1 specification) pub fn shard_and_committees_for_cycle( seed: &[u8], - validators: &[ValidatorRecord], + validators: &[Validator], crosslinking_shard_start: u16, spec: &ChainSpec, ) -> Result { diff --git a/validator_client/src/block_producer/grpc.rs b/validator_client/src/block_producer/grpc.rs index 033965b16..87f1b2cff 100644 --- a/validator_client/src/block_producer/grpc.rs +++ b/validator_client/src/block_producer/grpc.rs @@ -4,7 +4,7 @@ use protos::services::{ }; use protos::services_grpc::BeaconBlockServiceClient; use ssz::{ssz_encode, Decodable}; -use types::{BeaconBlock, BeaconBlockBody, Hash256, Signature}; +use types::{BeaconBlock, BeaconBlockBody, Eth1Data, Hash256, Signature}; impl BeaconNode for BeaconBlockServiceClient { /// Request a Beacon Node (BN) to produce a new block at the supplied slot. @@ -25,13 +25,19 @@ impl BeaconNode for BeaconBlockServiceClient { let (signature, _) = Signature::ssz_decode(block.get_signature(), 0) .map_err(|_| BeaconNodeError::DecodeFailure)?; + let (randao_reveal, _) = Signature::ssz_decode(block.get_randao_reveal(), 0) + .map_err(|_| BeaconNodeError::DecodeFailure)?; + // TODO: this conversion is incomplete; fix it. Ok(Some(BeaconBlock { slot: block.get_slot(), parent_root: Hash256::zero(), state_root: Hash256::zero(), - randao_reveal: Hash256::from(block.get_randao_reveal()), - candidate_pow_receipt_root: Hash256::zero(), + randao_reveal, + eth1_data: Eth1Data { + deposit_root: Hash256::zero(), + block_hash: Hash256::zero(), + }, signature, body: BeaconBlockBody { proposer_slashings: vec![], @@ -60,7 +66,7 @@ impl BeaconNode for BeaconBlockServiceClient { let mut grpc_block = GrpcBeaconBlock::new(); grpc_block.set_slot(block.slot); grpc_block.set_block_root(vec![0]); - grpc_block.set_randao_reveal(block.randao_reveal.to_vec()); + grpc_block.set_randao_reveal(ssz_encode(&block.randao_reveal)); grpc_block.set_signature(ssz_encode(&block.signature)); req.set_block(grpc_block);