Hybrid version working with new_head handled at the ValidatorSet

Author: rodrigo-o

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -121,35 +121,35 @@ defmodule LambdaEthereumConsensus.Validator do
     state
     |> update_state(slot, head_root)
     |> maybe_attest(slot)
-    |> maybe_build_payload(slot + 1)
+    |> maybe_build_payload(slot + 1, head_root)
   end
 
-  @spec handle_tick({Types.slot(), atom()}, state) :: state
-  def handle_tick(_logical_time, %{validator: %{index: nil}} = state) do
+  @spec handle_tick({Types.slot(), atom()}, state, Types.root()) :: state
+  def handle_tick(_logical_time, %{validator: %{index: nil}} = state, _root) do
     log_error("-1", "setup validator", "index not present for handle tick")
     state
   end
 
-  def handle_tick({slot, :first_third}, state) do
+  def handle_tick({slot, :first_third}, state, root) do
     log_debug(state.validator.index, "started first third", slot: slot)
     # Here we may:
     # 1. propose our blocks
     # 2. (TODO) start collecting attestations for aggregation
-    maybe_propose(state, slot)
-    |> update_state(slot, state.root)
+    maybe_propose(state, slot, root)
+    |> update_state(slot, root)
   end
 
-  def handle_tick({slot, :second_third}, state) do
+  def handle_tick({slot, :second_third}, state, root) do
     log_debug(state.validator.index, "started second third", slot: slot)
     # Here we may:
     # 1. send our attestation for an empty slot
     # 2. start building a payload
     state
     |> maybe_attest(slot)
-    |> maybe_build_payload(slot + 1)
+    |> maybe_build_payload(slot + 1, root)
   end
 
-  def handle_tick({slot, :last_third}, state) do
+  def handle_tick({slot, :last_third}, state, _root) do
     log_debug(state.validator.index, "started last third", slot: slot)
     # Here we may publish our attestation aggregate
     maybe_publish_aggregate(state, slot)
@@ -395,8 +395,8 @@ defmodule LambdaEthereumConsensus.Validator do
 
   defp proposer?(%{duties: %{proposer: slots}}, slot), do: Enum.member?(slots, slot)
 
-  @spec maybe_build_payload(state, Types.slot()) :: state
-  defp maybe_build_payload(%{root: head_root} = state, proposed_slot) do
+  @spec maybe_build_payload(state, Types.slot(), Types.root()) :: state
+  defp maybe_build_payload(state, proposed_slot, head_root) do
     if proposer?(state, proposed_slot) do
       start_payload_builder(state, proposed_slot, head_root)
     else
@@ -409,7 +409,7 @@ defmodule LambdaEthereumConsensus.Validator do
 
   def start_payload_builder(%{validator: validator} = state, proposed_slot, head_root) do
     # TODO: handle reorgs and late blocks
-    log_debug(validator.index, "starting building payload for slot #{proposed_slot}")
+    log_debug(validator.index, "starting building payload for slot #{proposed_slot}", root: head_root)
 
     case BlockBuilder.start_building_payload(proposed_slot, head_root) do
       {:ok, payload_id} ->
@@ -424,21 +424,21 @@ defmodule LambdaEthereumConsensus.Validator do
     end
   end
 
-  defp maybe_propose(state, slot) do
+  defp maybe_propose(state, slot, root) do
     if proposer?(state, slot) do
-      propose(state, slot)
+      propose(state, slot, root)
     else
       state
     end
   end
 
   defp propose(
          %{
-           root: head_root,
            validator: validator,
            payload_builder: {proposed_slot, head_root, payload_id}
          } = state,
-         proposed_slot
+         proposed_slot,
+         head_root
        ) do
     log_debug(validator.index, "building block", slot: proposed_slot)
 
@@ -467,7 +467,7 @@ defmodule LambdaEthereumConsensus.Validator do
   end
 
   # TODO: at least in kurtosis there are blocks that are proposed without a payload apparently, must investigate.
-  defp propose(%{payload_builder: nil} = state, _proposed_slot) do
+  defp propose(%{payload_builder: nil} = state, _proposed_slot, _head_root) do
     log_error(state.validator.index, "propose block", "lack of execution payload")
     state
   end

lib/lambda_ethereum_consensus/validator/validator_set.ex

@@ -58,24 +58,27 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
 
     Logger.info("[Validator] Initialized #{Enum.count(validators)} validators")
 
-    {:ok, proposers} = Duties.compute_proposers_for_epoch(beacon, epoch, validators)
-    {:ok, attesters} = Duties.compute_attesters_for_epoch(beacon, epoch, validators)
-
-    Logger.info("[Validator] Proposers: #{inspect(proposers, pretty: true)}")
-    Logger.info("[Validator] Attesters: #{inspect(attesters, pretty: true)}")
+    duties = compute_duties_for_epoch!(beacon, epoch, validators)
 
     %__MODULE__{
       epoch: epoch,
       slot: slot,
       head_root: head_root,
-      duties: %{epoch => %{
-        proposers: proposers,
-        attesters: attesters
-      }},
+      duties: %{epoch => duties},
       validators: validators
     }
   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)}")
+
+    %{proposers: proposers, attesters: attesters}
+  end
+
   defp fetch_target_state!(epoch, head_root) do
     {:ok, state} = CheckpointStates.compute_target_checkpoint_state(epoch, head_root)
     state
@@ -86,14 +89,31 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   """
   @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)
+
     set
+    |> update_state(slot, head_root)
     |> attest(epoch, slot)
     |> build_next_payload(epoch, slot, head_root)
-    |> update_state(slot, head_root)
   end
 
   defp update_state(set, slot, head_root) do
-    %{set | slot: slot, head_root: head_root}
+    if new_epoch?(set, slot + 1) do
+      epoch = Misc.compute_epoch_at_slot(slot + 1)
+      beacon = fetch_target_state!(epoch, head_root)
+
+      duties = compute_duties_for_epoch!(beacon, epoch, set.validators)
+
+      %{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
+  end
+
+  defp new_epoch?(set, slot) do
+    epoch = Misc.compute_epoch_at_slot(slot)
+    epoch > set.epoch
   end
 
   defp attest(set, epoch, slot) do
@@ -119,7 +139,7 @@ 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)}
+        %{set | validators: Map.put(set.validators, updated_validator.validator.index, %{updated_validator | root: head_root})}
     end
   end
 
@@ -139,12 +159,12 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   Notify all validators of a new tick.
   """
   @spec notify_tick(t(), tuple()) :: t()
-  def notify_tick(%{validators: validators} = set, slot_data) do
+  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)}
+            {k, Validator.handle_tick(slot_data, v, head_root)}
           end)
         end,
         {:on_tick, slot_data}
@@ -154,14 +174,14 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   end
 
   defp maybe_debug_notify(fun, data) do
-    if Application.get_env(:logger, :level) == :debug do
-      Logger.debug("[Validator] Notifying all Validators with message: #{inspect(data)}")
+    if Application.get_env(:logger, :level) == :info do # :debug do
+      Logger.info("[Validator] Notifying all Validators with message: #{inspect(data)}")
 
       start_time = System.monotonic_time(:millisecond)
       result = fun.()
       end_time = System.monotonic_time(:millisecond)
 
-      Logger.debug(
+      Logger.info(
         "[Validator] #{inspect(data)} notified to all Validators after #{end_time - start_time} ms"
       )