mirror of
https://github.com/sigp/lighthouse.git
synced 2026-03-23 14:54:45 +00:00
Initial work towards v0.2.0 (#924)
* Remove ping protocol
* Initial renaming of network services
* Correct rebasing relative to latest master
* Start updating types
* Adds HashMapDelay struct to utils
* Initial network restructure
* Network restructure. Adds new types for v0.2.0
* Removes build artefacts
* Shift validation to beacon chain
* Temporarily remove gossip validation
This is to be updated to match current optimisation efforts.
* Adds AggregateAndProof
* Begin rebuilding pubsub encoding/decoding
* Signature hacking
* Shift gossipsup decoding into eth2_libp2p
* Existing EF tests passing with fake_crypto
* Shifts block encoding/decoding into RPC
* Delete outdated API spec
* All release tests passing bar genesis state parsing
* Update and test YamlConfig
* Update to spec v0.10 compatible BLS
* Updates to BLS EF tests
* Add EF test for AggregateVerify
And delete unused hash2curve tests for uncompressed points
* Update EF tests to v0.10.1
* Use optional block root correctly in block proc
* Use genesis fork in deposit domain. All tests pass
* Fast aggregate verify test
* Update REST API docs
* Fix unused import
* Bump spec tags to v0.10.1
* Add `seconds_per_eth1_block` to chainspec
* Update to timestamp based eth1 voting scheme
* Return None from `get_votes_to_consider` if block cache is empty
* Handle overflows in `is_candidate_block`
* Revert to failing tests
* Fix eth1 data sets test
* Choose default vote according to spec
* Fix collect_valid_votes tests
* Fix `get_votes_to_consider` to choose all eligible blocks
* Uncomment winning_vote tests
* Add comments; remove unused code
* Reduce seconds_per_eth1_block for simulation
* Addressed review comments
* Add test for default vote case
* Fix logs
* Remove unused functions
* Meter default eth1 votes
* Fix comments
* Progress on attestation service
* Address review comments; remove unused dependency
* Initial work on removing libp2p lock
* Add LRU caches to store (rollup)
* Update attestation validation for DB changes (WIP)
* Initial version of should_forward_block
* Scaffold
* Progress on attestation validation
Also, consolidate prod+testing slot clocks so that they share much
of the same implementation and can both handle sub-slot time changes.
* Removes lock from libp2p service
* Completed network lock removal
* Finish(?) attestation processing
* Correct network termination future
* Add slot check to block check
* Correct fmt issues
* Remove Drop implementation for network service
* Add first attempt at attestation proc. re-write
* Add version 2 of attestation processing
* Minor fixes
* Add validator pubkey cache
* Make get_indexed_attestation take a committee
* Link signature processing into new attn verification
* First working version
* Ensure pubkey cache is updated
* Add more metrics, slight optimizations
* Clone committee cache during attestation processing
* Update shuffling cache during block processing
* Remove old commented-out code
* Fix shuffling cache insert bug
* Used indexed attestation in fork choice
* Restructure attn processing, add metrics
* Add more detailed metrics
* Tidy, fix failing tests
* Fix failing tests, tidy
* Address reviewers suggestions
* Disable/delete two outdated tests
* Modification of validator for subscriptions
* Add slot signing to validator client
* Further progress on validation subscription
* Adds necessary validator subscription functionality
* Add new Pubkeys struct to signature_sets
* Refactor with functional approach
* Update beacon chain
* Clean up validator <-> beacon node http types
* Add aggregator status to ValidatorDuty
* Impl Clone for manual slot clock
* Fix minor errors
* Further progress validator client subscription
* Initial subscription and aggregation handling
* Remove decompressed member from pubkey bytes
* Progress to modifying val client for attestation aggregation
* First draft of validator client upgrade for aggregate attestations
* Add hashmap for indices lookup
* Add state cache, remove store cache
* Only build the head committee cache
* Removes lock on a network channel
* Partially implement beacon node subscription http api
* Correct compilation issues
* Change `get_attesting_indices` to use Vec
* Fix failing test
* Partial implementation of timer
* Adds timer, removes exit_future, http api to op pool
* Partial multiple aggregate attestation handling
* Permits bulk messages accross gossipsub network channel
* Correct compile issues
* Improve gosispsub messaging and correct rest api helpers
* Added global gossipsub subscriptions
* Update validator subscriptions data structs
* Tidy
* Re-structure validator subscriptions
* Initial handling of subscriptions
* Re-structure network service
* Add pubkey cache persistence file
* Add more comments
* Integrate persistence file into builder
* Add pubkey cache tests
* Add HashSetDelay and introduce into attestation service
* Handles validator subscriptions
* Add data_dir to beacon chain builder
* Remove Option in pubkey cache persistence file
* Ensure consistency between datadir/data_dir
* Fix failing network test
* Peer subnet discovery gets queued for future subscriptions
* Reorganise attestation service functions
* Initial wiring of attestation service
* First draft of attestation service timing logic
* Correct minor typos
* Tidy
* Fix todos
* Improve tests
* Add PeerInfo to connected peers mapping
* Fix compile error
* Fix compile error from merge
* Split up block processing metrics
* Tidy
* Refactor get_pubkey_from_state
* Remove commented-out code
* Rename state_cache -> checkpoint_cache
* Rename Checkpoint -> Snapshot
* Tidy, add comments
* Tidy up find_head function
* Change some checkpoint -> snapshot
* Add tests
* Expose max_len
* Remove dead code
* Tidy
* Fix bug
* Add sync-speed metric
* Add first attempt at VerifiableBlock
* Start integrating into beacon chain
* Integrate VerifiableBlock
* Rename VerifableBlock -> PartialBlockVerification
* Add start of typed methods
* Add progress
* Add further progress
* Rename structs
* Add full block verification to block_processing.rs
* Further beacon chain integration
* Update checks for gossip
* Add todo
* Start adding segement verification
* Add passing chain segement test
* Initial integration with batch sync
* Minor changes
* Tidy, add more error checking
* Start adding chain_segment tests
* Finish invalid signature tests
* Include single and gossip verified blocks in tests
* Add gossip verification tests
* Start adding docs
* Finish adding comments to block_processing.rs
* Rename block_processing.rs -> block_verification
* Start removing old block processing code
* Fixes beacon_chain compilation
* Fix project-wide compile errors
* Remove old code
* Correct code to pass all tests
* Fix bug with beacon proposer index
* Fix shim for BlockProcessingError
* Only process one epoch at a time
* Fix loop in chain segment processing
* Correct tests from master merge
* Add caching for state.eth1_data_votes
* Add BeaconChain::validator_pubkey
* Revert "Add caching for state.eth1_data_votes"
This reverts commit cd73dcd643.
Co-authored-by: Grant Wuerker <gwuerker@gmail.com>
Co-authored-by: Michael Sproul <michael@sigmaprime.io>
Co-authored-by: Michael Sproul <micsproul@gmail.com>
Co-authored-by: pawan <pawandhananjay@gmail.com>
Co-authored-by: Paul Hauner <paul@paulhauner.com>
This commit is contained in:
Age Manning
@@ -1,19 +1,20 @@
|
||||
use crate::{
|
||||
duties_service::{DutiesService, ValidatorDuty},
|
||||
duties_service::{DutiesService, DutyAndState},
|
||||
validator_store::ValidatorStore,
|
||||
};
|
||||
use environment::RuntimeContext;
|
||||
use exit_future::Signal;
|
||||
use futures::{Future, Stream};
|
||||
use remote_beacon_node::{PublishStatus, RemoteBeaconNode};
|
||||
use rest_types::{ValidatorDuty, ValidatorSubscription};
|
||||
use slog::{crit, info, trace};
|
||||
use slot_clock::SlotClock;
|
||||
use std::collections::HashMap;
|
||||
use std::ops::Deref;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::timer::Interval;
|
||||
use types::{ChainSpec, CommitteeIndex, EthSpec, Slot};
|
||||
use tokio::timer::{Delay, Interval};
|
||||
use types::{AggregateAndProof, ChainSpec, CommitteeIndex, EthSpec, Slot};
|
||||
|
||||
/// Builds an `AttestationService`.
|
||||
pub struct AttestationServiceBuilder<T, E: EthSpec> {
|
||||
@@ -123,13 +124,13 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
let context = &self.context;
|
||||
let log = context.log.clone();
|
||||
|
||||
let slot_duration = Duration::from_millis(spec.milliseconds_per_slot);
|
||||
let duration_to_next_slot = self
|
||||
.slot_clock
|
||||
.duration_to_next_slot()
|
||||
.ok_or_else(|| "Unable to determine duration to next slot".to_string())?;
|
||||
|
||||
let interval = {
|
||||
let slot_duration = Duration::from_millis(spec.milliseconds_per_slot);
|
||||
Interval::new(
|
||||
Instant::now() + duration_to_next_slot + slot_duration / 3,
|
||||
slot_duration,
|
||||
@@ -154,7 +155,7 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
}
|
||||
})
|
||||
.for_each(move |_| {
|
||||
if let Err(e) = service.spawn_attestation_tasks() {
|
||||
if let Err(e) = service.spawn_attestation_tasks(slot_duration) {
|
||||
crit!(
|
||||
log_2,
|
||||
"Failed to spawn attestation tasks";
|
||||
@@ -178,30 +179,73 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
|
||||
/// For each each required attestation, spawn a new task that downloads, signs and uploads the
|
||||
/// attestation to the beacon node.
|
||||
fn spawn_attestation_tasks(&self) -> Result<(), String> {
|
||||
fn spawn_attestation_tasks(&self, slot_duration: Duration) -> Result<(), String> {
|
||||
let service = self.clone();
|
||||
|
||||
let slot = service
|
||||
.slot_clock
|
||||
.now()
|
||||
.ok_or_else(|| "Failed to read slot clock".to_string())?;
|
||||
let duration_to_next_slot = service
|
||||
.slot_clock
|
||||
.duration_to_next_slot()
|
||||
.ok_or_else(|| "Unable to determine duration to next slot".to_string())?;
|
||||
|
||||
// If a validator needs to publish an aggregate attestation, they must do so at 2/3
|
||||
// through the slot. This delay triggers at this time
|
||||
let aggregator_delay_instant = {
|
||||
if duration_to_next_slot <= slot_duration / 3 {
|
||||
Instant::now()
|
||||
} else {
|
||||
Instant::now() + duration_to_next_slot - (slot_duration / 3)
|
||||
}
|
||||
};
|
||||
|
||||
let epoch = slot.epoch(E::slots_per_epoch());
|
||||
// Check if any attestation subscriptions are required. If there a new attestation duties for
|
||||
// this epoch or the next, send them to the beacon node
|
||||
let mut duties_to_subscribe = service.duties_service.unsubscribed_epoch_duties(&epoch);
|
||||
duties_to_subscribe.append(
|
||||
&mut service
|
||||
.duties_service
|
||||
.unsubscribed_epoch_duties(&(epoch + 1)),
|
||||
);
|
||||
|
||||
// spawn a task to subscribe all the duties
|
||||
service
|
||||
.context
|
||||
.executor
|
||||
.spawn(self.clone().send_subscriptions(duties_to_subscribe));
|
||||
|
||||
// Builds a map of committee index and spawn individual tasks to process raw attestations
|
||||
// and aggregated attestations
|
||||
let mut committee_indices: HashMap<CommitteeIndex, Vec<ValidatorDuty>> = HashMap::new();
|
||||
let mut aggregator_committee_indices: HashMap<CommitteeIndex, Vec<DutyAndState>> =
|
||||
HashMap::new();
|
||||
|
||||
service
|
||||
.duties_service
|
||||
.attesters(slot)
|
||||
.into_iter()
|
||||
.for_each(|duty| {
|
||||
if let Some(committee_index) = duty.attestation_committee_index {
|
||||
.for_each(|duty_and_state| {
|
||||
if let Some(committee_index) = duty_and_state.duty.attestation_committee_index {
|
||||
let validator_duties = committee_indices
|
||||
.entry(committee_index)
|
||||
.or_insert_with(|| vec![]);
|
||||
validator_duties.push(duty_and_state.duty.clone());
|
||||
|
||||
validator_duties.push(duty);
|
||||
// If this duty entails the validator aggregating attestations, perform
|
||||
// aggregation tasks
|
||||
if duty_and_state.is_aggregator() {
|
||||
let validator_duties = aggregator_committee_indices
|
||||
.entry(committee_index)
|
||||
.or_insert_with(|| vec![]);
|
||||
validator_duties.push(duty_and_state);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// spawns tasks for all required raw attestations production
|
||||
committee_indices
|
||||
.into_iter()
|
||||
.for_each(|(committee_index, validator_duties)| {
|
||||
@@ -213,11 +257,112 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
));
|
||||
});
|
||||
|
||||
// spawns tasks for all aggregate attestation production
|
||||
aggregator_committee_indices
|
||||
.into_iter()
|
||||
.for_each(|(committee_index, validator_duties)| {
|
||||
// Spawn a separate task for each aggregate attestation.
|
||||
service
|
||||
.context
|
||||
.executor
|
||||
.spawn(self.clone().do_aggregate_attestation(
|
||||
slot,
|
||||
committee_index,
|
||||
validator_duties,
|
||||
Delay::new(aggregator_delay_instant.clone()),
|
||||
));
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// For a given `committee_index`, download the attestation, have it signed by all validators
|
||||
/// in `validator_duties` then upload it.
|
||||
/// Subscribes any required validators to the beacon node for a particular slot.
|
||||
///
|
||||
/// This informs the beacon node that the validator has a duty on a particular
|
||||
/// slot allowing the beacon node to connect to the required subnet and determine
|
||||
/// if attestations need to be aggregated.
|
||||
fn send_subscriptions(&self, duties: Vec<ValidatorDuty>) -> impl Future<Item = (), Error = ()> {
|
||||
let mut validator_subscriptions = Vec::new();
|
||||
let mut successful_duties = Vec::new();
|
||||
|
||||
let service_1 = self.clone();
|
||||
let duties_no = duties.len();
|
||||
|
||||
let log_1 = self.context.log.clone();
|
||||
let log_2 = self.context.log.clone();
|
||||
|
||||
// builds a list of subscriptions
|
||||
for duty in duties {
|
||||
if let Some((slot, attestation_committee_index, _, validator_index)) =
|
||||
attestation_duties(&duty)
|
||||
{
|
||||
if let Some(slot_signature) =
|
||||
self.validator_store.sign_slot(&duty.validator_pubkey, slot)
|
||||
{
|
||||
let is_aggregator_proof = if duty.is_aggregator(&slot_signature) {
|
||||
Some(slot_signature.clone())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let subscription = ValidatorSubscription::new(
|
||||
validator_index,
|
||||
attestation_committee_index,
|
||||
slot,
|
||||
slot_signature,
|
||||
);
|
||||
validator_subscriptions.push(subscription);
|
||||
|
||||
// add successful duties to the list, along with whether they are aggregation
|
||||
// duties or not
|
||||
successful_duties.push((duty, is_aggregator_proof));
|
||||
}
|
||||
} else {
|
||||
crit!(log_2, "Validator duty doesn't have required fields");
|
||||
}
|
||||
}
|
||||
|
||||
let failed_duties = duties_no - successful_duties.len();
|
||||
|
||||
self.beacon_node
|
||||
.http
|
||||
.validator()
|
||||
.subscribe(validator_subscriptions)
|
||||
.map_err(|e| format!("Failed to subscribe validators: {:?}", e))
|
||||
.map(move |publish_status| match publish_status {
|
||||
PublishStatus::Valid => info!(
|
||||
log_1,
|
||||
"Successfully subscribed validators";
|
||||
"validators" => duties_no,
|
||||
"failed_validators" => failed_duties,
|
||||
),
|
||||
PublishStatus::Invalid(msg) => crit!(
|
||||
log_1,
|
||||
"Validator Subscription was invalid";
|
||||
"message" => msg,
|
||||
),
|
||||
PublishStatus::Unknown => {
|
||||
crit!(log_1, "Unknown condition when publishing attestation")
|
||||
}
|
||||
})
|
||||
.and_then(move |_| {
|
||||
for (duty, is_aggregator_proof) in successful_duties {
|
||||
service_1
|
||||
.duties_service
|
||||
.subscribe_duty(&duty, is_aggregator_proof);
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
.map_err(move |e| {
|
||||
crit!(
|
||||
log_2,
|
||||
"Error during attestation production";
|
||||
"error" => e
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// For a given `committee_index`, download the attestation, have each validator in
|
||||
/// `validator_duties` sign it and send the collection back to the beacon node.
|
||||
fn do_attestation(
|
||||
&self,
|
||||
slot: Slot,
|
||||
@@ -235,28 +380,32 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
.produce_attestation(slot, committee_index)
|
||||
.map_err(|e| format!("Failed to produce attestation: {:?}", e))
|
||||
.map(move |attestation| {
|
||||
validator_duties
|
||||
.iter()
|
||||
.fold(attestation, |mut attestation, duty| {
|
||||
validator_duties.iter().fold(
|
||||
(Vec::new(), attestation),
|
||||
|(mut attestation_list, attestation), duty| {
|
||||
let log = service_1.context.log.clone();
|
||||
|
||||
if let Some((
|
||||
duty_slot,
|
||||
duty_committee_index,
|
||||
validator_committee_position,
|
||||
_,
|
||||
)) = attestation_duties(duty)
|
||||
{
|
||||
let mut raw_attestation = attestation.clone();
|
||||
if duty_slot == slot && duty_committee_index == committee_index {
|
||||
if service_1
|
||||
.validator_store
|
||||
.sign_attestation(
|
||||
&duty.validator_pubkey,
|
||||
validator_committee_position,
|
||||
&mut attestation,
|
||||
&mut raw_attestation,
|
||||
)
|
||||
.is_none()
|
||||
{
|
||||
crit!(log, "Failed to sign attestation");
|
||||
} else {
|
||||
attestation_list.push(raw_attestation);
|
||||
}
|
||||
} else {
|
||||
crit!(log, "Inconsistent validator duties during signing");
|
||||
@@ -265,22 +414,134 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
crit!(log, "Missing validator duties when signing");
|
||||
}
|
||||
|
||||
attestation
|
||||
})
|
||||
(attestation_list, attestation)
|
||||
},
|
||||
)
|
||||
})
|
||||
.and_then(move |attestation| {
|
||||
.and_then(move |(attestation_list, attestation)| {
|
||||
service_2
|
||||
.beacon_node
|
||||
.http
|
||||
.validator()
|
||||
.publish_attestation(attestation.clone())
|
||||
.publish_attestations(attestation_list.clone())
|
||||
.map(|publish_status| (attestation_list, attestation, publish_status))
|
||||
.map_err(|e| format!("Failed to publish attestations: {:?}", e))
|
||||
})
|
||||
.map(
|
||||
move |(attestation_list, attestation, publish_status)| match publish_status {
|
||||
PublishStatus::Valid => info!(
|
||||
log_1,
|
||||
"Successfully published attestation";
|
||||
"signatures" => attestation_list.len(),
|
||||
"head_block" => format!("{}", attestation.data.beacon_block_root),
|
||||
"committee_index" => attestation.data.index,
|
||||
"slot" => attestation.data.slot.as_u64(),
|
||||
),
|
||||
PublishStatus::Invalid(msg) => crit!(
|
||||
log_1,
|
||||
"Published attestation was invalid";
|
||||
"message" => msg,
|
||||
"committee_index" => attestation.data.index,
|
||||
"slot" => attestation.data.slot.as_u64(),
|
||||
),
|
||||
PublishStatus::Unknown => {
|
||||
crit!(log_1, "Unknown condition when publishing attestation")
|
||||
}
|
||||
},
|
||||
)
|
||||
.map_err(move |e| {
|
||||
crit!(
|
||||
log_2,
|
||||
"Error during attestation production";
|
||||
"error" => e
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// For a given `committee_index`, download the aggregate attestation, have it signed by all validators
|
||||
/// in `validator_duties` then upload it.
|
||||
fn do_aggregate_attestation(
|
||||
&self,
|
||||
slot: Slot,
|
||||
committee_index: CommitteeIndex,
|
||||
validator_duties: Vec<DutyAndState>,
|
||||
aggregator_delay: Delay,
|
||||
) -> impl Future<Item = (), Error = ()> {
|
||||
let service_1 = self.clone();
|
||||
let service_2 = self.clone();
|
||||
let log_1 = self.context.log.clone();
|
||||
let log_2 = self.context.log.clone();
|
||||
|
||||
self.beacon_node
|
||||
.http
|
||||
.validator()
|
||||
.produce_aggregate_attestation(slot, committee_index)
|
||||
.map_err(|e| format!("Failed to produce an aggregate attestation: {:?}", e))
|
||||
.map(move |attestation| {
|
||||
validator_duties.iter().fold(
|
||||
(Vec::new(), attestation),
|
||||
|(mut aggregate_and_proof_list, attestation), duty_and_state| {
|
||||
let log = service_1.context.log.clone();
|
||||
|
||||
match (
|
||||
duty_and_state.selection_proof(),
|
||||
attestation_duties(&duty_and_state.duty),
|
||||
) {
|
||||
(
|
||||
Some(selection_proof),
|
||||
Some((duty_slot, duty_committee_index, _, aggregator_index)),
|
||||
) => {
|
||||
let raw_attestation = attestation.clone();
|
||||
if duty_slot == slot && duty_committee_index == committee_index {
|
||||
// build the `AggregateAndProof` struct for each validator
|
||||
let aggregate_and_proof = AggregateAndProof {
|
||||
aggregator_index,
|
||||
aggregate: raw_attestation,
|
||||
selection_proof,
|
||||
};
|
||||
|
||||
if let Some(signed_aggregate_and_proof) =
|
||||
service_1.validator_store.sign_aggregate_and_proof(
|
||||
&duty_and_state.duty.validator_pubkey,
|
||||
aggregate_and_proof,
|
||||
)
|
||||
{
|
||||
aggregate_and_proof_list.push(signed_aggregate_and_proof);
|
||||
} else {
|
||||
crit!(log, "Failed to sign attestation");
|
||||
}
|
||||
} else {
|
||||
crit!(log, "Inconsistent validator duties during signing");
|
||||
}
|
||||
}
|
||||
_ => crit!(
|
||||
log,
|
||||
"Missing validator duties or not aggregate duty when signing"
|
||||
),
|
||||
}
|
||||
|
||||
(aggregate_and_proof_list, attestation)
|
||||
},
|
||||
)
|
||||
})
|
||||
.and_then(move |(aggregate_and_proof_list, attestation)| {
|
||||
aggregator_delay
|
||||
.map(move |_| (aggregate_and_proof_list, attestation))
|
||||
.map_err(move |e| format!("Error during aggregator delay: {:?}", e))
|
||||
})
|
||||
.and_then(move |(aggregate_and_proof_list, attestation)| {
|
||||
service_2
|
||||
.beacon_node
|
||||
.http
|
||||
.validator()
|
||||
.publish_aggregate_and_proof(aggregate_and_proof_list)
|
||||
.map(|publish_status| (attestation, publish_status))
|
||||
.map_err(|e| format!("Failed to publish attestation: {:?}", e))
|
||||
.map_err(|e| format!("Failed to publish aggregate and proofs: {:?}", e))
|
||||
})
|
||||
.map(move |(attestation, publish_status)| match publish_status {
|
||||
PublishStatus::Valid => info!(
|
||||
log_1,
|
||||
"Successfully published attestation";
|
||||
"Successfully published aggregate attestations";
|
||||
"signatures" => attestation.aggregation_bits.num_set_bits(),
|
||||
"head_block" => format!("{}", attestation.data.beacon_block_root),
|
||||
"committee_index" => attestation.data.index,
|
||||
@@ -307,10 +568,11 @@ impl<T: SlotClock + 'static, E: EthSpec> AttestationService<T, E> {
|
||||
}
|
||||
}
|
||||
|
||||
fn attestation_duties(duty: &ValidatorDuty) -> Option<(Slot, CommitteeIndex, usize)> {
|
||||
fn attestation_duties(duty: &ValidatorDuty) -> Option<(Slot, CommitteeIndex, usize, u64)> {
|
||||
Some((
|
||||
duty.attestation_slot?,
|
||||
duty.attestation_committee_index?,
|
||||
duty.attestation_committee_position?,
|
||||
duty.validator_index?,
|
||||
))
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user