Calculate proposers for the whole epoch

Author: rodrigo-o

lib/lambda_ethereum_consensus/validator/duties.ex

@@ -40,14 +40,18 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
     }
   end
 
-  @spec compute_proposers_for_epoch(beacon_state :: BeaconState.t(), epoch :: Types.epoch()) ::
+  @spec compute_proposers_for_epoch(beacon_state :: BeaconState.t(), epoch :: Types.epoch(), %{}) ::
           %{Types.slot() => non_neg_integer()}
-  def compute_proposers_for_epoch(beacon_state, epoch) do
+  def compute_proposers_for_epoch(beacon_state, epoch, validators) do
     start_slot = Misc.compute_start_slot_at_epoch(epoch)
 
     start_slot..(start_slot + ChainSpec.get("SLOTS_PER_EPOCH") - 1)
-    |> Enum.map(fn slot ->
-      {slot, Accessors.get_beacon_proposer_index(beacon_state, slot)}
+    |> Enum.flat_map(fn slot ->
+      validator_index = Accessors.get_beacon_proposer_index(beacon_state, slot)
+
+      if Map.has_key?(validators, validator_index),
+        do: [{slot, Accessors.get_beacon_proposer_index(beacon_state, slot)}],
+        else: []
     end)
     |> Map.new()
   end

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -48,11 +48,11 @@ defmodule LambdaEthereumConsensus.Validator do
           payload_builder: {Types.slot(), Types.root(), BlockBuilder.payload_id()} | nil
         }
 
-  @spec new({Types.slot(), Types.root(), {Bls.pubkey(), Bls.privkey()}}) :: state
-  def new({head_slot, head_root, {pubkey, privkey}}) do
+  @spec new({Bls.pubkey(), Bls.privkey()}, Types.epoch(), Types.slot(), Types.root(), Types.BeaconState.t()) :: state
+  def new({pubkey, privkey}, epoch, head_slot, head_root, beacon) do
     state = %__MODULE__{
       slot: head_slot,
-      epoch: Misc.compute_epoch_at_slot(head_slot),
+      epoch: epoch,
       root: head_root,
       duties: Duties.empty_duties(),
       validator: %{
@@ -63,7 +63,7 @@ defmodule LambdaEthereumConsensus.Validator do
       payload_builder: nil
     }
 
-    case try_setup_validator(state, head_slot, head_root) do
+    case try_setup_validator(state, epoch, head_slot, head_root, beacon) do
       nil ->
         # TODO: Previously this was handled by the validator continously trying to setup itself,
         # but now that they are processed syncronously, we should handle this case different.
@@ -76,11 +76,8 @@ defmodule LambdaEthereumConsensus.Validator do
     end
   end
 
-  @spec try_setup_validator(state, Types.slot(), Types.root()) :: state | nil
-  defp try_setup_validator(state, slot, root) do
-    epoch = Misc.compute_epoch_at_slot(slot)
-    beacon = fetch_target_state(epoch, root)
-
+  @spec try_setup_validator(state, Types.epoch(), Types.slot(), Types.root(), Types.BeaconState.t()) :: state | nil
+  defp try_setup_validator(state, epoch, slot, root, beacon) do
     case fetch_validator_index(beacon, state.validator) do
       nil ->
         nil

lib/lambda_ethereum_consensus/validator/validator_pool.ex

@@ -10,13 +10,15 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   require Logger
 
   alias LambdaEthereumConsensus.StateTransition.Misc
+  alias LambdaEthereumConsensus.Store.CheckpointStates
   alias LambdaEthereumConsensus.Validator
+  alias LambdaEthereumConsensus.Validator.Duties
 
-  @type validators :: %{atom() => list(Validator.state())}
+  @type validators :: %{atom() => %{} | []}
   @type t :: %__MODULE__{
-          epoch: Types.epoch(),
-          slot: Types.slot(),
-          head_root: Types.root(),
+          epoch: Types.epoch() | nil,
+          slot: Types.slot() | nil,
+          head_root: Types.root() | nil,
           validators: validators()
         }
 
@@ -44,18 +46,33 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   defp setup_validators(slot, head_root, keystore_dir, keystore_pass_dir) do
     validator_keys = decode_validator_keys(keystore_dir, keystore_pass_dir)
 
-    validators = Enum.map(validator_keys, &Validator.new({slot, head_root, &1}))
+    epoch = Misc.compute_epoch_at_slot(slot)
+    beacon = fetch_target_state!(epoch, head_root)
+
+    validators = Map.new(validator_keys, fn validator_key ->
+      validator = Validator.new(validator_key, epoch, slot, head_root, beacon)
+      {validator.validator.index, validator}
+    end)
 
     Logger.info("[Validator] Initialized #{Enum.count(validators)} validators")
 
+    proposers = Duties.compute_proposers_for_epoch(beacon, epoch, validators)
+
     %__MODULE__{
-      epoch: Misc.compute_epoch_at_slot(slot),
+      epoch: epoch,
       slot: slot,
       head_root: head_root,
-      validators: %{uninitialized: validators}
+      validators: %{
+        proposers: proposers,
+        uninitialized: validators}
     }
   end
 
+  defp fetch_target_state!(epoch, head_root) do
+    {:ok, state} = CheckpointStates.compute_target_checkpoint_state(epoch, head_root)
+    state
+  end
+
   @doc """
   Notify all validators of a new head.
   """
@@ -64,7 +81,9 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
     uninitialized_validators =
       maybe_debug_notify(
         fn ->
-          Enum.map(validators, &Validator.handle_new_head(slot, head_root, &1))
+          Map.new(validators, fn {k, v} ->
+            {k, Validator.handle_new_head(slot, head_root, v)}
+          end)
         end,
         {:new_head, slot, head_root}
       )
@@ -80,7 +99,9 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
     uninitialized_validators =
       maybe_debug_notify(
         fn ->
-          Enum.map(validators, &Validator.handle_tick(slot_data, &1))
+          Map.new(validators,  fn {k, v} ->
+            {k, Validator.handle_tick(slot_data, v)}
+          end)
         end,
         {:on_tick, slot_data}
       )