Removed slot and root from Validator and started cleaning up the ValidatorSet

Author: rodrigo-o

.iex.exs

@@ -5,8 +5,6 @@ defmodule LambdaEthereumConsensus.Validator do
   require Logger
 
   defstruct [
-    :slot,
-    :root,
     :epoch,
     :duties,
     :validator,
@@ -40,9 +38,7 @@ defmodule LambdaEthereumConsensus.Validator do
   # TODO: Slot and Root are redundant, we should also have the duties separated and calculated
   # just at the begining of every epoch, and then just update them as needed.
   @type state :: %__MODULE__{
-          slot: Types.slot(),
           epoch: Types.epoch(),
-          root: Types.root(),
           duties: Duties.duties(),
           validator: validator(),
           payload_builder: {Types.slot(), Types.root(), BlockBuilder.payload_id()} | nil
@@ -57,9 +53,7 @@ defmodule LambdaEthereumConsensus.Validator do
         ) :: state
   def new({pubkey, privkey}, epoch, head_slot, head_root, beacon) do
     state = %__MODULE__{
-      slot: head_slot,
       epoch: epoch,
-      root: head_root,
       duties: Duties.empty_duties(),
       validator: %{
         pubkey: pubkey,
@@ -120,7 +114,7 @@ defmodule LambdaEthereumConsensus.Validator do
     # TODO: this doesn't take into account reorgs
     state
     |> update_state(slot, head_root)
-    |> maybe_attest(slot)
+    |> maybe_attest(slot, head_root)
     |> maybe_build_payload(slot + 1, head_root)
   end
 
@@ -145,7 +139,7 @@ defmodule LambdaEthereumConsensus.Validator do
     # 1. send our attestation for an empty slot
     # 2. start building a payload
     state
-    |> maybe_attest(slot)
+    |> maybe_attest(slot, root)
     |> maybe_build_payload(slot + 1, root)
   end
 
@@ -168,7 +162,7 @@ defmodule LambdaEthereumConsensus.Validator do
     epoch = Misc.compute_epoch_at_slot(slot + 1)
 
     if last_epoch == epoch do
-      %{state | slot: slot, root: head_root}
+      state
     else
       recompute_duties(state, last_epoch, epoch, slot, head_root)
     end
@@ -189,7 +183,7 @@ defmodule LambdaEthereumConsensus.Validator do
     move_subnets(state.duties, new_duties)
     Duties.log_duties(new_duties, state.validator.index)
 
-    %{state | slot: slot, root: head_root, duties: new_duties, epoch: epoch}
+    %{state | duties: new_duties, epoch: epoch}
   end
 
   @spec fetch_target_state(Types.epoch(), Types.root()) :: Types.BeaconState.t()
@@ -230,11 +224,11 @@ defmodule LambdaEthereumConsensus.Validator do
     end
   end
 
-  @spec maybe_attest(state, Types.slot()) :: state
-  defp maybe_attest(state, slot) do
+  @spec maybe_attest(state, Types.slot(), Types.root()) :: state
+  defp maybe_attest(state, slot, head_root) do
     case Duties.get_current_attester_duty(state.duties, slot) do
       %{attested?: false} = duty ->
-        attest(state, duty)
+        attest(state, duty, head_root)
 
         new_duties =
           Duties.replace_attester_duty(state.duties, duty, %{duty | attested?: true})
@@ -246,12 +240,12 @@ defmodule LambdaEthereumConsensus.Validator do
     end
   end
 
-  @spec attest(state, Duties.attester_duty()) :: :ok
-  def attest(%{validator: validator} = state, current_duty) do
+  @spec attest(state, Duties.attester_duty(), Types.root()) :: :ok
+  def attest(%{validator: validator} = state, current_duty, head_root) do
     subnet_id = current_duty.subnet_id
     log_debug(validator.index, "attesting", slot: current_duty.slot, subnet_id: subnet_id)
 
-    attestation = produce_attestation(current_duty, state.root, state.validator.privkey)
+    attestation = produce_attestation(current_duty, head_root, state.validator.privkey)
 
     log_md = [slot: attestation.data.slot, attestation: attestation, subnet_id: subnet_id]
 
@@ -472,7 +466,7 @@ defmodule LambdaEthereumConsensus.Validator do
     state
   end
 
-  defp propose(state, proposed_slot) do
+  defp propose(state, proposed_slot, _head_root) do
     Logger.error(
       "[Validator] Skipping block proposal for slot #{proposed_slot} due to missing validator data"
     )

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -5,7 +5,7 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   simplify the delegation of work.
   """
 
-  defstruct epoch: nil, slot: nil, head_root: nil, duties: %{}, validators: []
+  defstruct head_root: nil, duties: %{}, validators: []
 
   require Logger
 
@@ -16,8 +16,6 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
 
   @type validators :: %{atom() => %{} | []}
   @type t :: %__MODULE__{
-          epoch: Types.epoch() | nil,
-          slot: Types.slot() | nil,
           head_root: Types.root() | nil,
           duties: %{Types.epoch() => %{proposers: Duties.proposers(), attesters: Duties.attesters()}},
           validators: validators()
@@ -35,7 +33,43 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
     setup_validators(slot, head_root, keystore_dir, keystore_pass_dir)
   end
 
-  defp setup_validators(_s, _r, keystore_dir, keystore_pass_dir)
+  @doc """
+  Notify all validators of a new head.
+  """
+  @spec notify_head(t(), Types.slot(), Types.root()) :: t()
+  def notify_head(%{validators: validators} = set, slot, head_root) do
+    # TODO: Just for testing purposes, remove it later
+    Logger.info("[Validator] Notifying all Validators with new_head", root: head_root, slot: slot)
+    epoch = Misc.compute_epoch_at_slot(slot)
+
+    set
+    |> update_state(epoch, slot, head_root)
+    |> attest(epoch, slot, head_root)
+    |> build_next_payload(epoch, slot, head_root)
+  end
+
+  @doc """
+  Notify all validators of a new tick.
+  """
+  @spec notify_tick(t(), tuple()) :: t()
+  def notify_tick(%{validators: validators, head_root: head_root} = set, slot_data) do
+    validators =
+      maybe_debug_notify(
+        fn ->
+          Map.new(validators, fn {k, v} ->
+            {k, Validator.handle_tick(slot_data, v, head_root)}
+          end)
+        end,
+        {:on_tick, slot_data}
+      )
+
+    %{set | validators: validators}
+  end
+
+  ##############################
+  # Setup
+
+    defp setup_validators(_s, _r, keystore_dir, keystore_pass_dir)
        when is_nil(keystore_dir) or is_nil(keystore_pass_dir) do
     Logger.warning(
       "[Validator] No keystore_dir or keystore_pass_dir provided. Validators won't start."
@@ -46,9 +80,10 @@ 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)
-
     epoch = Misc.compute_epoch_at_slot(slot)
-    beacon = fetch_target_state!(epoch, head_root)
+
+    # This will be removed later when refactoring Validator new
+    beacon = fetch_target_beaconstate!(epoch, head_root)
 
     validators =
       Map.new(validator_keys, fn validator_key ->
@@ -58,76 +93,70 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
 
     Logger.info("[Validator] Initialized #{Enum.count(validators)} validators")
 
-    duties = compute_duties_for_epoch!(beacon, epoch, validators)
-
-    %__MODULE__{
-      epoch: epoch,
-      slot: slot,
-      head_root: head_root,
-      duties: %{epoch => duties},
-      validators: validators
-    }
+    %__MODULE__{validators: validators}
+    |> update_state(epoch, slot, head_root)
   end
 
-  defp compute_duties_for_epoch!(beacon, epoch, validators) do
-    {:ok, proposers} = Duties.compute_proposers_for_epoch(beacon, epoch, validators)
-    {:ok, attesters} = Duties.compute_attesters_for_epoch(beacon, epoch, validators)
-
-    Logger.info("[Validator] Proposer duties for epoch #{epoch} are: #{inspect(proposers, pretty: true)}")
-    Logger.info("[Validator] Attester duties for epoch #{epoch} are: #{inspect(attesters, pretty: true)}")
+  ##############################
+  # State update
 
-    %{proposers: proposers, attesters: attesters}
+  defp update_state(set, epoch, slot, head_root) do
+    set
+    |> update_head(head_root)
+    |> compute_duties(epoch, slot, head_root)
   end
 
-  defp fetch_target_state!(epoch, head_root) do
-    {:ok, state} = CheckpointStates.compute_target_checkpoint_state(epoch, head_root)
-    state
-  end
+  defp update_head(%{head_root: head_root} = set, head_root), do: set
+  defp update_head(set, head_root), do: %{set | head_root: head_root}
 
-  @doc """
-  Notify all validators of a new head.
-  """
-  @spec notify_head(t(), Types.slot(), Types.root()) :: t()
-  def notify_head(%{validators: validators, epoch: epoch} = set, slot, head_root) do
-    # TODO: Just for testing purposes, remove it later
-    Logger.info("[Validator] Notifying all Validators with new_head", root: head_root, slot: slot)
+  defp compute_duties(set, epoch, _slot, _head_root)
+    when not is_nil(:erlang.map_get(epoch, set.duties)), do: set
 
-    set
-    |> update_state(slot, head_root)
-    |> attest(epoch, slot)
-    |> build_next_payload(epoch, slot, head_root)
+  defp compute_duties(set, epoch, slot, head_root) do
+    epoch
+    |> fetch_target_beaconstate!(head_root)
+    |> compute_duties_for_epoch!(epoch, set.validators)
+    |> merge_duties_and_prune(epoch, set)
+  end
+
+  defp fetch_target_beaconstate!(epoch, head_root) do
+    {:ok, beaconstate} = CheckpointStates.compute_target_checkpoint_state(epoch, head_root)
+    beaconstate
   end
 
-  defp update_state(set, slot, head_root) do
-    if new_epoch?(set, slot + 1) do
-      epoch = Misc.compute_epoch_at_slot(slot + 1)
-      beacon = fetch_target_state!(epoch, head_root)
+  defp compute_duties_for_epoch!(beacon, epoch, validators) do
+    {:ok, proposers} = Duties.compute_proposers_for_epoch(beacon, epoch, validators)
+    {:ok, attesters} = Duties.compute_attesters_for_epoch(beacon, epoch, validators)
 
-      duties = compute_duties_for_epoch!(beacon, epoch, set.validators)
+    Logger.info("[Validator] Proposer duties for epoch #{epoch} are: #{inspect(proposers, pretty: true)}")
+    Logger.info("[Validator] Attester duties for epoch #{epoch} are: #{inspect(attesters, pretty: true)}")
 
-      %{set | epoch: epoch, slot: slot, head_root: head_root, duties: Map.put(set.duties, epoch, duties)}
-    else
-      %{set | slot: slot, head_root: head_root}
-    end
+    %{epoch => %{proposers: proposers, attesters: attesters}}
   end
 
-  defp new_epoch?(set, slot) do
-    epoch = Misc.compute_epoch_at_slot(slot)
-    epoch > set.epoch
+  defp merge_duties_and_prune(new_duties, epoch, set) do
+    set.duties
+    # Remove duties from epoch - 2 or older
+    |> Map.reject(fn {old_epoch, _} -> old_epoch < epoch - 2 end)
+    |> Map.merge(new_duties)
+    |> then(fn current_duties -> %{set | duties: current_duties} end)
   end
 
-  defp attest(set, epoch, slot) do
+  ##############################
+  # Attestation and proposal
+
+  defp attest(set, epoch, slot, root) do
     updated_duties =
       set
       |> current_attesters(epoch, slot)
       |> Enum.map(fn {validator, duty} ->
-        Validator.attest(validator, duty)
+        Validator.attest(validator, duty, root)
 
         # Duty.attested(duty)
         %{duty | attested?: true}
       end)
 
-    %{set | duties: put_in(set.duties, [set.epoch, :attesters, slot], updated_duties)}
+    %{set | duties: put_in(set.duties, [epoch, :attesters, slot], updated_duties)}
   end
 
   defp build_next_payload(set, epoch, slot, head_root) do
@@ -139,10 +168,13 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
         validator = Map.get(set.validators, validator_index)
         updated_validator = Validator.start_payload_builder(validator, slot + 1, head_root)
 
-        %{set | validators: Map.put(set.validators, updated_validator.validator.index, %{updated_validator | root: head_root})}
+        %{set | validators: Map.put(set.validators, updated_validator.validator.index, updated_validator)}
     end
   end
 
+  ##############################
+  # Helpers
+
   defp current_attesters(set, epoch, slot) do
     attesters(set, epoch, slot)
     |> Enum.flat_map(fn
@@ -154,25 +186,6 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   defp proposer(set, epoch, slot), do: get_in(set.duties, [epoch, :proposers, slot])
   defp attesters(set, epoch, slot), do: get_in(set.duties, [epoch, :attesters, slot]) || []
 
-
-  @doc """
-  Notify all validators of a new tick.
-  """
-  @spec notify_tick(t(), tuple()) :: t()
-  def notify_tick(%{validators: validators, head_root: head_root} = set, slot_data) do
-    validators =
-      maybe_debug_notify(
-        fn ->
-          Map.new(validators, fn {k, v} ->
-            {k, Validator.handle_tick(slot_data, v, head_root)}
-          end)
-        end,
-        {:on_tick, slot_data}
-      )
-
-    %{set | validators: validators}
-  end
-
   defp maybe_debug_notify(fun, data) do
     if Application.get_env(:logger, :level) == :info do # :debug do
       Logger.info("[Validator] Notifying all Validators with message: #{inspect(data)}")