Formatted and fixed all lint and dialyzer issues

Author: rodrigo-o

lib/lambda_ethereum_consensus/beacon/beacon_node.ex

@@ -32,7 +32,8 @@ defmodule LambdaEthereumConsensus.Beacon.BeaconNode do
 
     validator_set = ValidatorSet.init(store.head_slot, store.head_root)
 
-    libp2p_args = [genesis_time: store.genesis_time, validator_set: validator_set] ++ get_libp2p_args()
+    libp2p_args =
+      [genesis_time: store.genesis_time, validator_set: validator_set] ++ get_libp2p_args()
 
     children =
       [

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 Types.BeaconState
 
@@ -44,7 +45,6 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
   def 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
-
       start_slot..end_slot
       |> Enum.flat_map(fn slot ->
         {:ok, proposer_index} = Accessors.get_beacon_proposer_index(state, slot)
@@ -61,7 +61,6 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
   def 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)
 
       start_slot..end_slot
@@ -77,27 +76,31 @@ defmodule LambdaEthereumConsensus.Validator.Duties do
           state :: BeaconState.t(),
           epoch :: Types.epoch(),
           slot :: Types.slot(),
-          committee_index :: Types.uint64(),
-          validator_index :: [{Types.validator_index(), Validator.validator()}]
-        ) :: [attester_duty()]
+          validators :: %{Types.validator_index() => Validator.t()},
+          committee_index :: Types.uint64()
+        ) :: [{Types.slot(), attester_duty()}]
   defp compute_attester_dutys(state, epoch, slot, validators, committee_index) do
     with {:ok, committee} <- Accessors.get_beacon_committee(state, slot, committee_index) do
       committee
       |> Stream.with_index()
       |> Stream.flat_map(fn {validator_index, index_in_committee} ->
         case Map.get(validators, validator_index) do
-          nil -> []
+          nil ->
+            []
+
           validator ->
-           [%{
-              slot: slot,
-              validator_index: validator_index,
-              index_in_committee: index_in_committee,
-              committee_length: length(committee),
-              committee_index: committee_index,
-              attested?: false
-            }
-            |> update_with_aggregation_duty(state, validator.keystore.privkey)
-            |> update_with_subnet_id(state, epoch)]
+            [
+              %{
+                slot: slot,
+                validator_index: validator_index,
+                index_in_committee: index_in_committee,
+                committee_length: length(committee),
+                committee_index: committee_index,
+                attested?: false
+              }
+              |> update_with_aggregation_duty(state, validator.keystore.privkey)
+              |> update_with_subnet_id(state, epoch)
+            ]
         end
       end)
       |> Enum.into([])

lib/lambda_ethereum_consensus/validator/validator.ex

@@ -42,10 +42,8 @@ defmodule LambdaEthereumConsensus.Validator do
 
   @spec new(
           Keystore.t(),
-          Types.epoch(),
           Types.slot(),
-          Types.root(),
-          Types.BeaconState.t()
+          Types.root()
         ) :: t()
   def new(keystore, head_slot, head_root) do
     epoch = Misc.compute_epoch_at_slot(head_slot)
@@ -184,9 +182,10 @@ defmodule LambdaEthereumConsensus.Validator do
   end
 
   @spec recompute_duties(t(), Types.epoch(), Types.epoch(), Types.slot(), Types.root()) :: t()
-  defp recompute_duties(state, last_epoch, epoch, slot, head_root) do
+  defp recompute_duties(state, last_epoch, epoch, _slot, head_root) do
     start_slot = Misc.compute_start_slot_at_epoch(epoch)
-    # Why is this needed? something here seems wrong, why would i need to move to a different slot if
+
+    # TODO: Why is this needed? something here seems wrong, why would i need to move to a different slot if
     # I'm calculating this at a new epoch? need to check it
     # target_root = if slot == start_slot, do: head_root, else: last_root
 
@@ -259,7 +258,7 @@ defmodule LambdaEthereumConsensus.Validator do
   end
 
   @spec attest(t(), Duties.attester_duty(), Types.root()) :: :ok
-  def attest(%{index: validator_index, keystore: keystore} = state, current_duty, head_root) do
+  def attest(%{index: validator_index, keystore: keystore}, current_duty, head_root) do
     subnet_id = current_duty.subnet_id
     log_debug(validator_index, "attesting", slot: current_duty.slot, subnet_id: subnet_id)
 
@@ -421,7 +420,9 @@ defmodule LambdaEthereumConsensus.Validator do
 
   def start_payload_builder(%{index: validator_index} = state, proposed_slot, head_root) do
     # TODO: handle reorgs and late blocks
-    log_debug(validator_index, "starting building payload for slot #{proposed_slot}", root: head_root)
+    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} ->

lib/lambda_ethereum_consensus/validator/validator_set.ex

@@ -17,7 +17,12 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   @type validators :: %{atom() => %{} | []}
   @type t :: %__MODULE__{
           head_root: Types.root() | nil,
-          duties: %{Types.epoch() => %{proposers: Duties.proposers(), attesters: Duties.attesters()}},
+          duties: %{
+            Types.epoch() => %{
+              proposers: Duties.proposer_duties(),
+              attesters: Duties.attester_duties()
+            }
+          },
           validators: validators()
         }
 
@@ -37,13 +42,13 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   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
+  def notify_head(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)
+    |> update_state(epoch, head_root)
     |> attest(epoch, slot, head_root)
     |> build_next_payload(epoch, slot, head_root)
   end
@@ -69,7 +74,7 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   ##############################
   # Setup
 
-    defp setup_validators(_s, _r, keystore_dir, keystore_pass_dir)
+  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."
@@ -94,25 +99,26 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
     Logger.info("[Validator] Initialized #{Enum.count(validators)} validators")
 
     %__MODULE__{validators: validators}
-    |> update_state(epoch, slot, head_root)
+    |> update_state(epoch, head_root)
   end
 
   ##############################
   # State update
 
-  defp update_state(set, epoch, slot, head_root) do
+  defp update_state(set, epoch, head_root) do
     set
     |> update_head(head_root)
-    |> compute_duties(epoch, slot, head_root)
+    |> compute_duties(epoch, head_root)
   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}
 
-  defp compute_duties(set, epoch, _slot, _head_root)
-    when not is_nil(:erlang.map_get(epoch, set.duties)), do: set
+  defp compute_duties(set, epoch, _head_root)
+       when not is_nil(:erlang.map_get(epoch, set.duties)),
+       do: set
 
-  defp compute_duties(set, epoch, slot, head_root) do
+  defp compute_duties(set, epoch, head_root) do
     epoch
     |> fetch_target_beaconstate!(head_root)
     |> compute_duties_for_epoch!(epoch, set.validators)
@@ -128,8 +134,13 @@ defmodule LambdaEthereumConsensus.ValidatorSet 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)}")
+    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)}"
+    )
 
     %{epoch => %{proposers: proposers, attesters: attesters}}
   end
@@ -163,7 +174,9 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
     set
     |> proposer(epoch, slot + 1)
     |> case do
-      nil -> set
+      nil ->
+        set
+
       validator_index ->
         validator = Map.get(set.validators, validator_index)
         updated_validator = Validator.start_payload_builder(validator, slot + 1, head_root)
@@ -187,7 +200,8 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
   defp attesters(set, epoch, slot), do: get_in(set.duties, [epoch, :attesters, slot]) || []
 
   defp maybe_debug_notify(fun, data) do
-    if Application.get_env(:logger, :level) == :info do # :debug do
+    # :debug do
+    if Application.get_env(:logger, :level) == :info do
       Logger.info("[Validator] Notifying all Validators with message: #{inspect(data)}")
 
       start_time = System.monotonic_time(:millisecond)
@@ -211,7 +225,7 @@ defmodule LambdaEthereumConsensus.ValidatorSet do
       - <keystore_pass_dir>/<public_key>.txt
   """
   @spec decode_validator_keystores(binary(), binary()) ::
-  list(Keystore.t())
+          list(Keystore.t())
   def decode_validator_keystores(keystore_dir, keystore_pass_dir)
       when is_binary(keystore_dir) and is_binary(keystore_pass_dir) do
     keystore_dir

lib/libp2p_port.ex

@@ -23,6 +23,7 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
   alias LambdaEthereumConsensus.P2p.Requests
   alias LambdaEthereumConsensus.StateTransition.Misc
   alias LambdaEthereumConsensus.Utils.BitVector
+  alias LambdaEthereumConsensus.Validator
   alias LambdaEthereumConsensus.ValidatorSet
   alias Libp2pProto.AddPeer
   alias Libp2pProto.Command
@@ -541,14 +542,17 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
 
   @impl GenServer
   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}
+    do:
+      {:reply,
+       Enum.map(validator_set.validators, fn {_index, validator} -> validator.keystore end),
+       state}
 
   @impl GenServer
   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} ->
+      {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)}
@@ -560,15 +564,16 @@ defmodule LambdaEthereumConsensus.Libp2pPort do
 
   @impl GenServer
   def handle_call(
-        {:add_validator, %Keystore{pubkey: pubkey} = keystore},
+        {:add_validator, keystore},
         _from,
-        %{validator_set: %{head_root: head_root} = validator_set, slot_data: {slot, _third}} = state
+        %{validator_set: %{head_root: head_root}, slot_data: {slot, _third}} =
+          state
       ) do
     # TODO (#1263): handle 0 validators
     validator = Validator.new(keystore, slot, head_root)
 
     Logger.warning(
-      "[Libp2pPort] Adding validator with index #{inspect(validator.index)}. head_slot: #{inspect(validator.slot)}."
+      "[Libp2pPort] Adding validator with index #{inspect(validator.index)}. head_slot: #{inspect(slot)}."
     )
 
     {:reply, :ok, put_in(state.validator_set, [:validators, validator.index], validator)}