Initial sync_committee duty recalculation

Author: rodrigo-o

lib/lambda_ethereum_consensus/validator/duties.ex

@@ -4,6 +4,7 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
   """
   alias LambdaEthereumConsensus.StateTransition.Accessors
   alias LambdaEthereumConsensus.StateTransition.Misc
+  alias LambdaEthereumConsensus.Validator
   alias LambdaEthereumConsensus.Validator.Utils
   alias LambdaEthereumConsensus.ValidatorSet
   alias Types.BeaconState
@@ -44,69 +45,42 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
         }
 
   ############################
-  # Accessors
-
-  @spec current_proposer(duties(), Types.epoch(), Types.slot()) :: proposer_duty() | nil
-  def current_proposer(duties, epoch, slot),
-    do: get_in(duties, [epoch, :proposers, slot])
+  # Main Compute functions
 
-  @spec current_sync_committee(duties(), Types.epoch(), Types.slot()) ::
-          sync_committee_duties()
-  def current_sync_committee(duties, epoch, slot) do
-    for %{last_slot_broadcasted: last_slot} = duty <- sync_committee(duties, epoch),
-        last_slot < slot do
-      duty
-    end
-  end
-
-  @spec current_attesters(duties(), Types.epoch(), Types.slot()) :: attester_duties()
-  def current_attesters(duties, epoch, slot) do
-    for %{attested?: false} = duty <- attesters(duties, epoch, slot) do
-      duty
-    end
-  end
+  @spec compute_duties_for_epochs(
+          %{Types.epoch() => duties()},
+          [{Types.epoch(), Types.slot()}],
+          Types.root(),
+          ValidatorSet.validators()
+        ) :: duties()
+  def compute_duties_for_epochs(duties_map, epochs_and_start_slots, head_root, validators) do
+    for {epoch, slot} <- epochs_and_start_slots, reduce: duties_map do
+      duties_map ->
+        beacon = Validator.fetch_target_state_and_go_to_slot(slot, head_root)
+        last_epoch = Map.keys(duties_map) |> Enum.max(fn -> 0 end)
+
+        new_proposers = compute_proposers_for_epoch(beacon, epoch, validators)
+        new_attesters = compute_attesters_for_epoch(beacon, epoch, validators)
+
+        new_sync_committees =
+          case sync_committee_compute_check(epoch, {last_epoch, Map.get(duties_map, last_epoch)}) do
+            {:already_computed, sync_committees} -> sync_committees
+            :not_computed -> compute_current_sync_committees(beacon, validators)
+          end
+
+        new_duties = %{
+          proposers: new_proposers,
+          attesters: new_attesters,
+          sync_committees: new_sync_committees
+        }
 
-  @spec current_aggregators(duties(), Types.epoch(), Types.slot()) :: attester_duties()
-  def current_aggregators(duties, epoch, slot) do
-    for %{should_aggregate?: true} = duty <- attesters(duties, epoch, slot) do
-      duty
+        Map.put(duties_map, epoch, new_duties)
     end
   end
 
-  defp sync_committee(duties, epoch), do: get_in(duties, [epoch, :sync_committees]) || []
-  defp attesters(duties, epoch, slot), do: get_in(duties, [epoch, :attesters, slot]) || []
-
-  ############################
-  # Update functions
-
-  @spec update_duties!(
-          duties(),
-          kind(),
-          Types.epoch(),
-          Types.slot(),
-          attester_duties() | proposer_duties()
-        ) :: duties()
-  def update_duties!(duties, :sync_committees, epoch, _slot, updated),
-    do: put_in(duties, [epoch, :sync_committees], updated)
-
-  def update_duties!(duties, kind, epoch, slot, updated),
-    do: put_in(duties, [epoch, kind, slot], updated)
-
-  @spec attested(attester_duty()) :: attester_duty()
-  def attested(duty), do: Map.put(duty, :attested?, true)
-
-  @spec aggregated(attester_duty()) :: attester_duty()
-  def aggregated(duty), do: Map.put(duty, :should_aggregate?, false)
-
-  @spec sync_committee_broadcasted(sync_committee_duty(), Types.slot()) :: sync_committee_duty()
-  def sync_committee_broadcasted(duty, slot), do: Map.put(duty, :last_slot_broadcasted, slot)
-
-  ############################
-  # Main functions
-
   @spec compute_proposers_for_epoch(BeaconState.t(), Types.epoch(), ValidatorSet.validators()) ::
           proposer_duties_per_slot()
-  def compute_proposers_for_epoch(%BeaconState{} = state, epoch, validators) do
+  defp compute_proposers_for_epoch(%BeaconState{} = state, epoch, validators) do
     with {:ok, epoch} <- check_valid_epoch(state, epoch),
          {start_slot, end_slot} <- boundary_slots(epoch) do
       for slot <- start_slot..end_slot,
@@ -120,7 +94,7 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
 
   @spec compute_current_sync_committees(BeaconState.t(), ValidatorSet.validators()) ::
           sync_committee_duties()
-  def compute_current_sync_committees(%BeaconState{} = state, validators) do
+  defp compute_current_sync_committees(%BeaconState{} = state, validators) do
     for validator_index <- Map.keys(validators),
         subnet_ids = Utils.compute_subnets_for_sync_committee(state, validator_index) do
       %{
@@ -131,9 +105,20 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
     end
   end
 
+  defp sync_committee_compute_check(_epoch, {_last_epoch, nil}), do: :not_computed
+
+  defp sync_committee_compute_check(epoch, {last_epoch, last_duties}) do
+    last_period = Misc.compute_sync_committee_period(last_epoch)
+    current_period = Misc.compute_sync_committee_period(epoch)
+
+    if last_period == current_period,
+      do: {:already_computed, last_duties.sync_committees},
+      else: :not_computed
+  end
+
   @spec compute_attesters_for_epoch(BeaconState.t(), Types.epoch(), ValidatorSet.validators()) ::
           attester_duties_per_slot()
-  def compute_attesters_for_epoch(%BeaconState{} = state, epoch, validators) do
+  defp compute_attesters_for_epoch(%BeaconState{} = state, epoch, validators) do
     with {:ok, epoch} <- check_valid_epoch(state, epoch),
          {start_slot, end_slot} <- boundary_slots(epoch) do
       committee_count_per_slot = Accessors.get_committee_count_per_slot(state, epoch)
@@ -193,6 +178,64 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
     Map.put(duty, :subnet_id, subnet_id)
   end
 
+  ############################
+  # Accessors
+
+  @spec current_proposer(duties(), Types.epoch(), Types.slot()) :: proposer_duty() | nil
+  def current_proposer(duties, epoch, slot),
+    do: get_in(duties, [epoch, :proposers, slot])
+
+  @spec current_sync_committee(duties(), Types.epoch(), Types.slot()) ::
+          sync_committee_duties()
+  def current_sync_committee(duties, epoch, slot) do
+    for %{last_slot_broadcasted: last_slot} = duty <- sync_committee(duties, epoch),
+        last_slot < slot do
+      duty
+    end
+  end
+
+  @spec current_attesters(duties(), Types.epoch(), Types.slot()) :: attester_duties()
+  def current_attesters(duties, epoch, slot) do
+    for %{attested?: false} = duty <- attesters(duties, epoch, slot) do
+      duty
+    end
+  end
+
+  @spec current_aggregators(duties(), Types.epoch(), Types.slot()) :: attester_duties()
+  def current_aggregators(duties, epoch, slot) do
+    for %{should_aggregate?: true} = duty <- attesters(duties, epoch, slot) do
+      duty
+    end
+  end
+
+  defp sync_committee(duties, epoch), do: get_in(duties, [epoch, :sync_committees]) || []
+  defp attesters(duties, epoch, slot), do: get_in(duties, [epoch, :attesters, slot]) || []
+
+  ############################
+  # Update functions
+
+  @spec update_duties!(
+          duties(),
+          kind(),
+          Types.epoch(),
+          Types.slot(),
+          attester_duties() | proposer_duties()
+        ) :: duties()
+  def update_duties!(duties, :sync_committees, epoch, _slot, updated),
+    do: put_in(duties, [epoch, :sync_committees], updated)
+
+  def update_duties!(duties, kind, epoch, slot, updated),
+    do: put_in(duties, [epoch, kind, slot], updated)
+
+  @spec attested(attester_duty()) :: attester_duty()
+  def attested(duty), do: Map.put(duty, :attested?, true)
+
+  @spec aggregated(attester_duty()) :: attester_duty()
+  def aggregated(duty), do: Map.put(duty, :should_aggregate?, false)
+
+  @spec sync_committee_broadcasted(sync_committee_duty(), Types.slot()) :: sync_committee_duty()
+  def sync_committee_broadcasted(duty, slot), do: Map.put(duty, :last_slot_broadcasted, slot)
+
   ############################
   # Helpers
 

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -38,8 +38,7 @@ defmodule LambdaEthereumConsensus.Validator do
 
   @spec new(Keystore.t(), Types.slot(), Types.root()) :: t()
   def new(keystore, head_slot, head_root) do
-    epoch = Misc.compute_epoch_at_slot(head_slot)
-    beacon = fetch_target_state_and_go_to_slot(epoch, head_slot, head_root)
+    beacon = fetch_target_state_and_go_to_slot(head_slot, head_root)
 
     state = %__MODULE__{
       index: nil,
@@ -86,9 +85,11 @@ defmodule LambdaEthereumConsensus.Validator do
   ##########################
   # Target State
 
-  @spec fetch_target_state_and_go_to_slot(Types.epoch(), Types.slot(), Types.root()) ::
+  @spec fetch_target_state_and_go_to_slot(Types.slot(), Types.root()) ::
           Types.BeaconState.t()
-  def fetch_target_state_and_go_to_slot(epoch, slot, root) do
+  def fetch_target_state_and_go_to_slot(slot, root) do
+    epoch = Misc.compute_epoch_at_slot(slot)
+
     epoch |> fetch_target_state(root) |> go_to_slot(slot)
   end
 

lib/lambda_ethereum_consensus/validator/validator_set.ex

@@ -132,25 +132,11 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
       [{epoch, slot}, {epoch + 1, Misc.compute_start_slot_at_epoch(epoch + 1)}]
       |> Enum.reject(&Map.has_key?(set.duties, elem(&1, 0)))
 
-    epochs_to_calculate
-    |> Map.new(&compute_duties_for_epoch!(set, &1, head_root))
+    set.duties
+    |> Duties.compute_duties_for_epochs(epochs_to_calculate, head_root, set.validators)
     |> merge_duties_and_prune(epoch, set)
   end
 
-  defp compute_duties_for_epoch!(set, {epoch, slot}, head_root) do
-    beacon = Validator.fetch_target_state_and_go_to_slot(epoch, slot, head_root)
-
-    duties = %{
-      proposers: Duties.compute_proposers_for_epoch(beacon, epoch, set.validators),
-      attesters: Duties.compute_attesters_for_epoch(beacon, epoch, set.validators),
-      sync_committees: Duties.compute_current_sync_committees(beacon, set.validators)
-    }
-
-    Duties.log_duties_for_epoch(duties, epoch)
-
-    {epoch, duties}
-  end
-
   defp merge_duties_and_prune(new_duties, current_epoch, set) do
     set.duties
     # Remove duties from epoch - 2 or older

network_params.yaml

@@ -8,6 +8,8 @@ participants:
     cl_image: lambda_ethereum_consensus:latest
     use_separate_vc: false
     count: 1
-    validator_count: 32
+    validator_count: 15
     cl_max_mem: 4096
     keymanager_enabled: true
+network_params:
+  preset: minimal