Fixed how keystore functions handle the validator set

Author: rodrigo-o

lib/lambda_ethereum_consensus/beacon/beacon_node.ex

@@ -30,9 +30,9 @@ defmodule LambdaEthereumConsensus.Beacon.BeaconNode do
 
     init_execution_chain(deposit_tree_snapshot, store.head_root)
 
-    validators = ValidatorSet.init(store.head_slot, store.head_root)
+    validator_set = ValidatorSet.init(store.head_slot, store.head_root)
 
-    libp2p_args = [genesis_time: store.genesis_time, validators: validators] ++ get_libp2p_args()
+    libp2p_args = [genesis_time: store.genesis_time, validator_set: validator_set] ++ get_libp2p_args()
 
     children =
       [

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -40,6 +40,20 @@ defmodule LambdaEthereumConsensus.Validator do
           payload_builder: {Types.slot(), Types.root(), BlockBuilder.payload_id()} | nil
         }
 
+  @spec new(
+          Keystore.t(),
+          Types.epoch(),
+          Types.slot(),
+          Types.root(),
+          Types.BeaconState.t()
+        ) :: t()
+  def new(keystore, head_slot, head_root) do
+    epoch = Misc.compute_epoch_at_slot(head_slot)
+    beacon = fetch_target_state(epoch, head_root) |> go_to_slot(head_slot)
+
+    new(keystore, epoch, head_slot, head_root, beacon)
+  end
+
   @spec new(
           Keystore.t(),
           Types.epoch(),

lib/libp2p_port.ex

@@ -65,7 +65,7 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
 
   @type init_arg ::
           {:genesis_time, Types.uint64()}
-          | {:validators, %{}}
+          | {:validator_set, ValidatorSet.t()}
           | {:listen_addr, [String.t()]}
           | {:enable_discovery, boolean()}
           | {:discovery_addr, String.t()}
@@ -388,7 +388,7 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
   @impl GenServer
   def init(args) do
     {genesis_time, args} = Keyword.pop!(args, :genesis_time)
-    {validators, args} = Keyword.pop(args, :validators, %{})
+    {validator_set, args} = Keyword.pop(args, :validator_set, %{})
     {join_init_topics, args} = Keyword.pop(args, :join_init_topics, false)
     {enable_request_handlers, args} = Keyword.pop(args, :enable_request_handlers, false)
 
@@ -416,7 +416,7 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
     {:ok,
      %{
        genesis_time: genesis_time,
-       validators: validators,
+       validator_set: validator_set,
        slot_data: nil,
        port: port,
        subscribers: %{},
@@ -514,11 +514,11 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
   end
 
   @impl GenServer
-  def handle_info({:new_head, slot, head_root}, %{validators: validators} = state) do
-    updated_validators =
-      ValidatorSet.notify_head(validators, slot, head_root)
+  def handle_info({:new_head, slot, head_root}, %{validator_set: validator_set} = state) do
+    updated_validator_set =
+      ValidatorSet.notify_head(validator_set, slot, head_root)
 
-    {:noreply, %{state | validators: updated_validators}}
+    {:noreply, %{state | validator_set: updated_validator_set}}
   end
 
   @impl GenServer
@@ -540,18 +540,20 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
   end
 
   @impl GenServer
-  def handle_call(:get_keystores, _from, %{validators: validators} = state),
-    do: {:reply, Enum.map(validators, fn {_pubkey, validator} -> validator.keystore end), state}
+  def handle_call(:get_keystores, _from, %{validator_set: validator_set} = state),
+    do: {:reply, Enum.map(validator_set.validators, fn {_index, validator} -> validator.keystore end), state}
 
   @impl GenServer
-  def handle_call({:delete_validator, pubkey}, _from, %{validators: validators} = state) do
-    case Map.fetch(validators, pubkey) do
-      {:ok, validator} ->
-        Logger.warning("[Libp2pPort] Deleting validator with index #{inspect(validator.index)}.")
-
-        {:reply, :ok, %{state | validators: Map.delete(validators, pubkey)}}
-
-      :error ->
+  def handle_call({:delete_validator, pubkey}, _from, %{validator_set: validator_set} = state) do
+    validator_set.validators
+    |> Enum.find(fn {_index, validator} -> validator.keystore.pubkey == pubkey end)
+    |> case do
+      {index, validator} ->
+        Logger.warning("[Libp2pPort] Deleting validator with index #{inspect(index)}.")
+        updated_validators = Map.delete(validator_set.validators, index)
+        {:reply, :ok, Map.put(state.validator_set, :validators, updated_validators)}
+
+      _ ->
         {:error, "Pubkey #{inspect(pubkey)} not found."}
     end
   end
@@ -560,26 +562,16 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
   def handle_call(
         {:add_validator, %Keystore{pubkey: pubkey} = keystore},
         _from,
-        %{validators: validators} = state
+        %{validator_set: %{head_root: head_root} = validator_set, slot_data: {slot, _third}} = state
       ) do
     # TODO (#1263): handle 0 validators
-    first_validator = validators |> Map.values() |> List.first()
-    validator = Validator.new({first_validator.slot, first_validator.root, keystore})
+    validator = Validator.new(keystore, slot, head_root)
 
     Logger.warning(
       "[Libp2pPort] Adding validator with index #{inspect(validator.index)}. head_slot: #{inspect(validator.slot)}."
     )
 
-    {:reply, :ok,
-     %{
-       state
-       | validators:
-           Map.put(
-             validators,
-             pubkey,
-             validator
-           )
-     }}
+    {:reply, :ok, put_in(state.validator_set, [:validators, validator.index], validator)}
   end
 
   ######################
@@ -799,10 +791,10 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
       if slot_data == new_slot_data do
         state
       else
-        updated_validators =
-          ValidatorSet.notify_tick(state.validators, new_slot_data)
+        updated_validator_set =
+          ValidatorSet.notify_tick(state.validator_set, new_slot_data)
 
-        %{state | slot_data: new_slot_data, validators: updated_validators}
+        %{state | slot_data: new_slot_data, validator_set: updated_validator_set}
       end
 
     maybe_log_new_slot(slot_data, new_slot_data)