/block.validate endpoint

apps/omg_watcher_rpc/lib/web/controllers/block.ex

@@ -19,6 +19,7 @@ defmodule OMG.WatcherRPC.Web.Controller.Block do
 
   use OMG.WatcherRPC.Web, :controller
 
+  alias OMG.Block
   alias OMG.WatcherInfo.API.Block, as: InfoApiBlock
   alias OMG.WatcherRPC.Web.Validator
 
@@ -43,4 +44,22 @@ defmodule OMG.WatcherRPC.Web.Controller.Block do
       |> api_response(conn, :blocks)
     end
   end
+
+  @doc """
+  Executes stateful and stateless validation of a block.
+  """
+  def validate_block(conn, params) do
+    with {:ok, block} <- Validator.BlockValidator.parse_to_validate(params),
+         {:ok, _block} <- stateless_validate(block) do
+      api_response(block, conn, :validate_block)
+    end
+  end
+
+  @spec stateless_validate(Block.t()) :: any
+  defp stateless_validate(block) do
+    with {:ok, block} <- Validator.BlockValidator.verify_merkle_root(block),
+         {:ok, block} <- Validator.BlockValidator.verify_transactions(block.transactions) do
+      {:ok, block}
+    end
+  end
 end

apps/omg_watcher_rpc/lib/web/controllers/fallback.ex

@@ -69,6 +69,10 @@ defmodule OMG.WatcherRPC.Web.Controller.Fallback do
       code: "transaction.create:self_transaction_not_supported",
       description: "This endpoint cannot be used to create merge or split transactions."
     },
+    invalid_merkle_root: %{
+      code: "block.validate:invalid_merkle_root",
+      description: "Block hash does not match reconstructed Merkle root."
+    },
     missing_signature: %{
       code: "submit_typed:missing_signature",
       description:

apps/omg_watcher_rpc/lib/web/router.ex

@@ -52,6 +52,8 @@ defmodule OMG.WatcherRPC.Web.Router do
 
     post("/account.get_exitable_utxos", Controller.Account, :get_exitable_utxos)
 
+    post("/block.validate", Controller.Block, :validate_block)
+
     post("/utxo.get_exit_data", Controller.Utxo, :get_utxo_exit)
     post("/utxo.get_challenge_data", Controller.Challenge, :get_utxo_challenge)
 

apps/omg_watcher_rpc/lib/web/validators/block_constraints.ex

@@ -16,6 +16,8 @@ defmodule OMG.WatcherRPC.Web.Validator.BlockConstraints do
   @moduledoc """
   Validates `/block.all` query parameters
   """
+
+  use OMG.WatcherRPC.Web, :controller
   alias OMG.WatcherRPC.Web.Validator.Helpers
 
   @doc """

apps/omg_watcher_rpc/lib/web/validators/block_validator.ex

@@ -0,0 +1,72 @@
+# Copyright 2019-2020 OmiseGO Pte Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+defmodule OMG.WatcherRPC.Web.Validator.BlockValidator do
+  @moduledoc """
+  Operations related to block validation.
+  """
+
+  use OMG.WatcherRPC.Web, :controller
+  alias OMG.Block
+  alias OMG.State.Transaction
+
+  @doc """
+  Validates that a block submitted for validation is correctly formed.
+  """
+  @spec parse_to_validate(Block.t()) :: {:error, {:validation_error, binary, any}} | {:ok, Block.t()}
+  def parse_to_validate(block) do
+    with {:ok, hash} <- expect(block, "hash", :hash),
+         {:ok, transactions} <- expect(block, "transactions", list: &is_hex/1),
+         {:ok, number} <- expect(block, "number", :pos_integer),
+         do: {:ok, %Block{hash: hash, transactions: transactions, number: number}}
+  end
+
+  @doc """
+  Verifies that given Merkle root matches reconstructed Merkle root.
+  """
+  @spec verify_merkle_root(Block.t()) :: {:ok, Block.t()} | {:error, :mismatched_merkle_root}
+  def verify_merkle_root(block) do
+    %{hash: reconstructed_merkle_root_hash} =
+      block.transactions
+      |> Enum.map(fn tx ->
+        {:ok, recovered_tx} = Transaction.Recovered.recover_from(tx)
+        recovered_tx
+      end)
+      |> OMG.Block.hashed_txs_at(block.number)
+
+    case block.hash == reconstructed_merkle_root_hash do
+      true -> {:ok, block}
+      _ -> {:error, :invalid_merkle_root}
+    end
+  end
+
+  @doc """
+  Verifies that transactions are correctly formed.
+  """
+  @spec verify_transactions(transactions :: list(Transaction.Recovered.t())) ::
+          {:ok, list(Transaction.Recovered.t())}
+          | {:error, Transaction.Recovered.recover_tx_error()}
+  def verify_transactions(transactions) do
+    Enum.reduce_while(transactions, {:ok, []}, fn tx, {:ok, already_recovered} ->
+      case Transaction.Recovered.recover_from(tx) do
+        {:ok, recovered} -> {:cont, {:ok, already_recovered ++ [recovered]}}
+        error -> {:halt, error}
+      end
+    end)
+  end
+
+  defp is_hex(original) do
+    expect(%{"hash" => original}, "hash", :hex)
+  end
+end

apps/omg_watcher_rpc/lib/web/views/block.ex

@@ -34,4 +34,10 @@ defmodule OMG.WatcherRPC.Web.View.Block do
     |> Response.serialize_page(data_paging)
     |> WatcherRPCResponse.add_app_infos()
   end
+
+  def render("validate_block.json", %{response: block}) do
+    block
+    |> Response.serialize()
+    |> WatcherRPCResponse.add_app_infos()
+  end
 end

apps/omg_watcher_rpc/test/omg_watcher_rpc/web/controllers/block_test.exs

@@ -16,11 +16,26 @@ defmodule OMG.WatcherRPC.Web.Controller.BlockTest do
   use ExUnitFixtures
   use ExUnit.Case, async: false
   use OMG.WatcherInfo.Fixtures
+  use OMG.WatcherRPC.Web, :controller
 
   import OMG.WatcherInfo.Factory
 
+  alias OMG.Eth.Encoding
+  alias OMG.Merkle
+  alias OMG.State.Transaction
+  alias OMG.TestHelper
+
   alias Support.WatcherHelper
 
+  @valid_block %{
+    hash: "0x" <> String.duplicate("00", 32),
+    number: 1000,
+    transactions: ["0x00"]
+  }
+  @eth OMG.Eth.zero_address()
+  @alice OMG.TestHelper.generate_entity()
+  @bob OMG.TestHelper.generate_entity()
+
   describe "get_block/2" do
     @tag fixtures: [:initial_blocks]
     test "/block.get returns correct block if existent" do
@@ -40,7 +55,9 @@ defmodule OMG.WatcherRPC.Web.Controller.BlockTest do
       expected = %{
         "code" => "operation:bad_request",
         "description" => "Parameters required by this operation are missing or incorrect.",
-        "messages" => %{"validation_error" => %{"parameter" => "blknum", "validator" => ":integer"}},
+        "messages" => %{
+          "validation_error" => %{"parameter" => "blknum", "validator" => ":integer"}
+        },
         "object" => "error"
       }
 
@@ -55,7 +72,9 @@ defmodule OMG.WatcherRPC.Web.Controller.BlockTest do
       expected = %{
         "code" => "operation:bad_request",
         "description" => "Parameters required by this operation are missing or incorrect.",
-        "messages" => %{"validation_error" => %{"parameter" => "blknum", "validator" => ":integer"}},
+        "messages" => %{
+          "validation_error" => %{"parameter" => "blknum", "validator" => ":integer"}
+        },
         "object" => "error"
       }
 
@@ -131,4 +150,89 @@ defmodule OMG.WatcherRPC.Web.Controller.BlockTest do
              } = response
     end
   end
+
+  describe "validate_block/2" do
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns the error API response if a parameter is incorectly formed" do
+      invalid_hash = "0x1234"
+      invalid_params = Map.replace!(@valid_block, :hash, invalid_hash)
+
+      %{"data" => data} = WatcherHelper.rpc_call("block.validate", invalid_params, 200)
+
+      expected = %{
+        "code" => "operation:bad_request",
+        "description" => "Parameters required by this operation are missing or incorrect.",
+        "messages" => %{
+          "validation_error" => %{
+            "parameter" => "hash",
+            "validator" => "{:length, 32}"
+          }
+        },
+        "object" => "error"
+      }
+
+      assert expected == data
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns the expected error if the block hash does not match the reconstructed Merkle root" do
+      recovered_tx_1 = TestHelper.create_recovered([{1, 0, 0, @alice}], @eth, [{@bob, 100}])
+      recovered_tx_2 = TestHelper.create_recovered([{2, 0, 0, @alice}], @eth, [{@bob, 100}])
+
+      signed_txbytes =
+        [recovered_tx_1, recovered_tx_2]
+        |> Enum.map(fn tx -> tx.signed_tx_bytes end)
+        |> Enum.map(&Encoding.to_hex/1)
+
+      invalid_merkle_root = "0x" <> String.duplicate("00", 32)
+
+      params = %{
+        hash: invalid_merkle_root,
+        number: 1000,
+        transactions: signed_txbytes
+      }
+
+      %{"data" => data} = WatcherHelper.rpc_call("block.validate", params, 200)
+
+      assert data == %{
+               "code" => "block.validate:invalid_merkle_root",
+               "description" => "Block hash does not match reconstructed Merkle root.",
+               "object" => "error"
+             }
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns the block if it is valid" do
+      recovered_tx_1 = TestHelper.create_recovered([{1, 0, 0, @alice}], @eth, [{@bob, 100}])
+      recovered_tx_2 = TestHelper.create_recovered([{2, 0, 0, @alice}], @eth, [{@bob, 100}])
+
+      signed_txbytes =
+        [recovered_tx_1, recovered_tx_2]
+        |> Enum.map(fn tx -> tx.signed_tx_bytes end)
+        |> Enum.map(&Encoding.to_hex/1)
+
+      valid_merkle_root =
+        [recovered_tx_1, recovered_tx_2]
+        |> Enum.map(&Transaction.raw_txbytes/1)
+        |> Merkle.hash()
+        |> Encoding.to_hex()
+
+      # Sanity check
+      assert {:ok, Encoding.from_hex(valid_merkle_root)} == expect(%{hash: valid_merkle_root}, :hash, :hash)
+
+      params = %{
+        hash: valid_merkle_root,
+        number: 1000,
+        transactions: signed_txbytes
+      }
+
+      %{"data" => data} = WatcherHelper.rpc_call("block.validate", params, 200)
+
+      assert data == %{
+               "hash" => params.hash,
+               "number" => params.number,
+               "transactions" => params.transactions
+             }
+    end
+  end
 end