test(spec): implement sync spec tests. (#700)

Co-authored-by: Tomás Grüner <47506558+MegaRedHand@users.noreply.github.com>

Author: mpaulucci

lib/lambda_ethereum_consensus/execution/engine_api/mocked.ex

@@ -20,6 +20,6 @@ defmodule LambdaEthereumConsensus.Execution.EngineApi.Mocked do
 
   @spec forkchoice_updated(map, map | any) :: {:ok, any} | {:error, any}
   def forkchoice_updated(_forkchoice_state, _payload_attributes) do
-    {:ok, %{"payload_id" => nil, payload_status: %{"status" => "SYNCING"}}}
+    {:ok, %{"payload_id" => nil, "payload_status" => %{"status" => "SYNCING"}}}
   end
 end

lib/lambda_ethereum_consensus/fork_choice/fork_choice.ex

@@ -7,7 +7,6 @@ defmodule LambdaEthereumConsensus.ForkChoice do
   require Logger
 
   alias LambdaEthereumConsensus.Beacon.BeaconChain
-  alias LambdaEthereumConsensus.Execution.ExecutionClient
   alias LambdaEthereumConsensus.ForkChoice.{Handlers, Helpers}
   alias LambdaEthereumConsensus.Store.Blocks
   alias Types.Attestation
@@ -180,21 +179,11 @@ defmodule LambdaEthereumConsensus.ForkChoice do
   @spec recompute_head(Store.t()) :: :ok
   def recompute_head(store) do
     {:ok, head_root} = Helpers.get_head(store)
-
     head_block = Blocks.get_block!(head_root)
-    head_execution_hash = head_block.body.execution_payload.block_hash
+
+    Handlers.notify_forkchoice_update(store, head_block)
 
     finalized_checkpoint = store.finalized_checkpoint
-    finalized_block = Blocks.get_block!(store.finalized_checkpoint.root)
-    finalized_execution_hash = finalized_block.body.execution_payload.block_hash
-
-    # TODO: do someting with the result from the execution client
-    # TODO: compute safe block hash
-    ExecutionClient.notify_forkchoice_updated(
-      head_execution_hash,
-      finalized_execution_hash,
-      finalized_execution_hash
-    )
 
     BeaconChain.update_fork_choice_cache(
       head_root,

lib/lambda_ethereum_consensus/fork_choice/handlers.ex

@@ -3,6 +3,7 @@ defmodule LambdaEthereumConsensus.ForkChoice.Handlers do
   Handlers that update the fork choice store.
   """
 
+  alias LambdaEthereumConsensus.Execution.ExecutionClient
   alias LambdaEthereumConsensus.StateTransition
   alias LambdaEthereumConsensus.StateTransition.{Accessors, EpochProcessing, Misc, Predicates}
   alias LambdaEthereumConsensus.Store.Blocks
@@ -184,6 +185,21 @@ defmodule LambdaEthereumConsensus.ForkChoice.Handlers do
     end
   end
 
+  def notify_forkchoice_update(store, head_block) do
+    head_execution_hash = head_block.body.execution_payload.block_hash
+
+    finalized_block = Blocks.get_block!(store.finalized_checkpoint.root)
+    finalized_execution_hash = finalized_block.body.execution_payload.block_hash
+
+    # TODO: do someting with the result from the execution client
+    # TODO: compute safe block hash
+    ExecutionClient.notify_forkchoice_updated(
+      head_execution_hash,
+      finalized_execution_hash,
+      finalized_execution_hash
+    )
+  end
+
   ### Private functions ###
 
   # Update checkpoints in store if necessary

test/spec/runners/fork_choice.ex

@@ -151,12 +151,18 @@ defmodule ForkChoiceTestRunner do
 
     assert Ssz.hash_tree_root!(block) == Base.decode16!(hash, case: :mixed)
 
-    with {:ok, new_store} <- Handlers.on_block(store, block) do
-      block.message.body.attestations
-      |> Enum.reduce_while({:ok, new_store}, fn
-        x, {:ok, st} -> {:cont, Handlers.on_attestation(st, x, true)}
-        _, {:error, _} = err -> {:halt, err}
-      end)
+    with {:ok, new_store} <- Handlers.on_block(store, block),
+         {:ok, new_store} <-
+           block.message.body.attestations
+           |> Enum.reduce_while({:ok, new_store}, fn
+             x, {:ok, st} -> {:cont, Handlers.on_attestation(st, x, true)}
+             _, {:error, _} = err -> {:halt, err}
+           end) do
+      {:ok, head_root} = Helpers.get_head(new_store)
+      head_block = Blocks.get_block!(head_root)
+
+      {:ok, _} = Handlers.notify_forkchoice_update(new_store, head_block)
+      {:ok, new_store}
     end
   end
 
@@ -182,6 +188,28 @@ defmodule ForkChoiceTestRunner do
     Handlers.on_attester_slashing(store, attester_slashing)
   end
 
+  defp apply_step(_case_dir, store, %{block_hash: block_hash, payload_status: payload_status}) do
+    # Convert keys to strings
+    normalized_payload_status =
+      Enum.reduce(payload_status, %{}, fn {k, v}, acc ->
+        Map.put(acc, Atom.to_string(k), v)
+      end)
+
+    :ok =
+      SyncTestRunner.EngineApiMock.add_new_payload_response(
+        block_hash,
+        normalized_payload_status
+      )
+
+    :ok =
+      SyncTestRunner.EngineApiMock.add_forkchoice_updated_response(
+        block_hash,
+        normalized_payload_status
+      )
+
+    {:ok, store}
+  end
+
   defp apply_step(_case_dir, store, %{checks: checks}) do
     if Map.has_key?(checks, :head) do
       {:ok, head_root} = Helpers.get_head(store)

test/spec/runners/sync.ex

@@ -6,9 +6,11 @@ defmodule SyncTestRunner do
   use ExUnit.CaseTemplate
   use TestRunner
 
+  alias LambdaEthereumConsensus.Execution.EngineApi
+
   @disabled_cases [
     # TODO: we have to support https://github.com/ethereum/consensus-specs/blob/dev/tests/formats/fork_choice/README.md#on_payload_info-execution-step
-    "from_syncing_to_invalid"
+    # "from_syncing_to_invalid"
   ]
 
   @impl TestRunner
@@ -18,6 +20,74 @@ defmodule SyncTestRunner do
 
   @impl TestRunner
   def run_test_case(%SpecTestCase{} = testcase) do
+    original_engine_api_config =
+      Application.fetch_env!(:lambda_ethereum_consensus, EngineApi)
+
+    Application.put_env(
+      :lambda_ethereum_consensus,
+      EngineApi,
+      Keyword.put(original_engine_api_config, :implementation, SyncTestRunner.EngineApiMock)
+    )
+
+    {:ok, _pid} = SyncTestRunner.EngineApiMock.start_link([])
+
     ForkChoiceTestRunner.run_test_case(testcase)
+
+    Application.put_env(
+      :lambda_ethereum_consensus,
+      EngineApi,
+      original_engine_api_config
+    )
+  end
+end
+
+defmodule SyncTestRunner.EngineApiMock do
+  @moduledoc """
+  Mocked EngineApi for SyncTestRunner.
+  """
+  use Agent
+
+  def start_link(_opts) do
+    Agent.start_link(fn -> %{new_payload: %{}, forkchoice_updated: %{}} end, name: __MODULE__)
+  end
+
+  def add_new_payload_response(block_hash, payload_status) do
+    Agent.update(__MODULE__, fn state ->
+      Map.update!(state, :new_payload, fn new_payload ->
+        Map.put(new_payload, block_hash, payload_status)
+      end)
+    end)
+  end
+
+  def add_forkchoice_updated_response(block_hash, payload_status) do
+    Agent.update(__MODULE__, fn state ->
+      Map.update!(state, :forkchoice_updated, fn forkchoice_updated ->
+        Map.put(forkchoice_updated, block_hash, payload_status)
+      end)
+    end)
+  end
+
+  def new_payload(payload) do
+    Agent.get(__MODULE__, fn state ->
+      payload_status = Map.get(state.new_payload, payload.block_hash)
+
+      if payload_status do
+        {:ok, payload_status}
+      else
+        {:error, "Unknown block hash when calling new_payload"}
+      end
+    end)
+  end
+
+  def forkchoice_updated(forkchoice_state, _payload_attributes) do
+    Agent.get(__MODULE__, fn state ->
+      payload_status = Map.get(state.forkchoice_updated, forkchoice_state.head_block_hash)
+
+      if payload_status do
+        {:ok, %{"payload_id" => nil, "payload_status" => payload_status}}
+      else
+        {:error, "Unknown block hash when calling forkchoice_updated"}
+      end
+    end)
   end
 end