feat: indexer for cross level messages on Arbitrum

apps/block_scout_web/lib/block_scout_web/api_router.ex

@@ -196,6 +196,10 @@ defmodule BlockScoutWeb.ApiRouter do
         get("/zksync-batch/:batch_number", V2.TransactionController, :zksync_batch)
       end
 
+      if Application.compile_env(:explorer, :chain_type) == :arbitrum do
+        get("/arbitrum-batch/:batch_number", V2.TransactionController, :arbitrum_batch)
+      end
+
       if Application.compile_env(:explorer, :chain_type) == :suave do
         get("/execution-node/:execution_node_hash_param", V2.TransactionController, :execution_node)
       end
@@ -219,6 +223,10 @@ defmodule BlockScoutWeb.ApiRouter do
       get("/:block_hash_or_number/transactions", V2.BlockController, :transactions)
       get("/:block_hash_or_number/internal-transactions", V2.BlockController, :internal_transactions)
       get("/:block_hash_or_number/withdrawals", V2.BlockController, :withdrawals)
+
+      if Application.compile_env(:explorer, :chain_type) == :arbitrum do
+        get("/arbitrum-batch/:batch_number", V2.BlockController, :arbitrum_batch)
+      end
     end
 
     scope "/addresses" do
@@ -277,6 +285,12 @@ defmodule BlockScoutWeb.ApiRouter do
         get("/zksync/batches/confirmed", V2.ZkSyncController, :batches_confirmed)
         get("/zksync/batches/latest-number", V2.ZkSyncController, :batch_latest_number)
       end
+
+      if Application.compile_env(:explorer, :chain_type) == :arbitrum do
+        get("/arbitrum/messages/to-rollup", V2.ArbitrumController, :recent_messages_to_l2)
+        get("/arbitrum/batches/committed", V2.ArbitrumController, :batches_committed)
+        get("/arbitrum/batches/latest-number", V2.ArbitrumController, :batch_latest_number)
+      end
     end
 
     scope "/stats" do
@@ -402,6 +416,16 @@ defmodule BlockScoutWeb.ApiRouter do
         get("/worlds/:world/tables/:table_id/records/:record_id", V2.MudController, :world_table_record)
       end
     end
+
+    scope "/arbitrum" do
+      if Application.compile_env(:explorer, :chain_type) == :arbitrum do
+        get("/messages/:direction", V2.ArbitrumController, :messages)
+        get("/messages/:direction/count", V2.ArbitrumController, :messages_count)
+        get("/batches", V2.ArbitrumController, :batches)
+        get("/batches/count", V2.ArbitrumController, :batches_count)
+        get("/batches/:batch_number", V2.ArbitrumController, :batch)
+      end
+    end
   end
 
   scope "/v1/graphql" do

apps/block_scout_web/lib/block_scout_web/chain.ex

@@ -433,7 +433,11 @@ defmodule BlockScoutWeb.Chain do
     end
   end
 
-  # clause for Polygon Edge Deposits and Withdrawals and for account's entities pagination
+  # clause for pagination of entities:
+  # - Account's entities
+  # - Polygon Edge Deposits
+  # - Polygon Edge Withdrawals
+  # - Arbitrum cross chain messages
   def paging_options(%{"id" => id_string}) when is_binary(id_string) do
     case Integer.parse(id_string) do
       {id, ""} ->
@@ -444,7 +448,11 @@ defmodule BlockScoutWeb.Chain do
     end
   end
 
-  # clause for Polygon Edge Deposits and Withdrawals and for account's entities pagination
+  # clause for pagination of entities:
+  # - Account's entities
+  # - Polygon Edge Deposits
+  # - Polygon Edge Withdrawals
+  # - Arbitrum cross chain messages
   def paging_options(%{"id" => id}) when is_integer(id) do
     [paging_options: %{@default_paging_options | key: {id}}]
   end

apps/block_scout_web/lib/block_scout_web/controllers/api/v2/arbitrum_controller.ex

@@ -0,0 +1,163 @@
+defmodule BlockScoutWeb.API.V2.ArbitrumController do
+  use BlockScoutWeb, :controller
+
+  import BlockScoutWeb.Chain,
+    only: [
+      next_page_params: 4,
+      paging_options: 1,
+      split_list_by_page: 1
+    ]
+
+  alias Explorer.PagingOptions
+  alias Explorer.Chain.Arbitrum.{L1Batch, Message, Reader}
+
+  action_fallback(BlockScoutWeb.API.V2.FallbackController)
+
+  @batch_necessity_by_association %{:commitment_transaction => :optional}
+
+  @doc """
+    Function to handle GET requests to `/api/v2/arbitrum/messages/:direction` endpoint.
+  """
+  @spec messages(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def messages(conn, %{"direction" => direction} = params) do
+    options =
+      params
+      |> paging_options()
+      |> Keyword.put(:api?, true)
+
+    {messages, next_page} =
+      direction
+      |> Reader.messages(options)
+      |> split_list_by_page()
+
+    next_page_params =
+      next_page_params(
+        next_page,
+        messages,
+        params,
+        fn %Message{message_id: msg_id} -> %{"id" => msg_id} end
+      )
+
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_messages, %{
+      messages: messages,
+      next_page_params: next_page_params
+    })
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/arbitrum/messages/:direction/count` endpoint.
+  """
+  @spec messages_count(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def messages_count(conn, %{"direction" => direction} = _params) do
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_messages_count, %{count: Reader.messages_count(direction, api?: true)})
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/arbitrum/batches/:batch_number` endpoint.
+  """
+  @spec batch(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def batch(conn, %{"batch_number" => batch_number} = _params) do
+    case Reader.batch(
+           batch_number,
+           necessity_by_association: @batch_necessity_by_association,
+           api?: true
+         ) do
+      {:ok, batch} ->
+        conn
+        |> put_status(200)
+        |> render(:arbitrum_batch, %{batch: batch})
+
+      {:error, :not_found} = res ->
+        res
+    end
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/arbitrum/batches/count` endpoint.
+  """
+  @spec batches_count(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def batches_count(conn, _params) do
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_batches_count, %{count: Reader.batches_count(api?: true)})
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/arbitrum/batches` endpoint.
+  """
+  @spec batches(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def batches(conn, params) do
+    {batches, next_page} =
+      params
+      |> paging_options()
+      |> Keyword.put(:necessity_by_association, @batch_necessity_by_association)
+      |> Keyword.put(:api?, true)
+      |> Reader.batches()
+      |> split_list_by_page()
+
+    next_page_params =
+      next_page_params(
+        next_page,
+        batches,
+        params,
+        fn %L1Batch{number: number} -> %{"number" => number} end
+      )
+
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_batches, %{
+      batches: batches,
+      next_page_params: next_page_params
+    })
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/main-page/arbitrum/batches/committed` endpoint.
+  """
+  @spec batches_committed(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def batches_committed(conn, _params) do
+    batches =
+      []
+      |> Keyword.put(:necessity_by_association, @batch_necessity_by_association)
+      |> Keyword.put(:api?, true)
+      |> Keyword.put(:committed?, true)
+      |> Reader.batches()
+
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_batches, %{batches: batches})
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/main-page/arbitrum/batches/latest-number` endpoint.
+  """
+  @spec batch_latest_number(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def batch_latest_number(conn, _params) do
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_batch_latest_number, %{number: batch_latest_number()})
+  end
+
+  defp batch_latest_number do
+    case Reader.batch(:latest, api?: true) do
+      {:ok, batch} -> batch.number
+      {:error, :not_found} -> 0
+    end
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/main-page/arbitrum/messages/to-rollup` endpoint.
+  """
+  @spec recent_messages_to_l2(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def recent_messages_to_l2(conn, _params) do
+    messages = Reader.relayed_l1_to_l2_messages(paging_options: %PagingOptions{page_size: 6}, api?: true)
+
+    conn
+    |> put_status(200)
+    |> render(:arbitrum_messages, %{messages: messages})
+  end
+end

apps/block_scout_web/lib/block_scout_web/controllers/api/v2/block_controller.ex

@@ -19,6 +19,7 @@ defmodule BlockScoutWeb.API.V2.BlockController do
 
   alias BlockScoutWeb.API.V2.{TransactionView, WithdrawalView}
   alias Explorer.Chain
+  alias Explorer.Chain.Arbitrum.Reader, as: ArbitrumReader
   alias Explorer.Chain.InternalTransaction
 
   case Application.compile_env(:explorer, :chain_type) do
@@ -39,6 +40,14 @@ defmodule BlockScoutWeb.API.V2.BlockController do
         :zksync_execute_transaction => :optional
       }
 
+    :arbitrum ->
+      @chain_type_transaction_necessity_by_association %{}
+      @chain_type_block_necessity_by_association %{
+        :arbitrum_batch => :optional,
+        :arbitrum_commitment_transaction => :optional,
+        :arbitrum_confirmation_transaction => :optional
+      }
+
     _ ->
       @chain_type_transaction_necessity_by_association %{}
       @chain_type_block_necessity_by_association %{}
@@ -85,20 +94,6 @@ defmodule BlockScoutWeb.API.V2.BlockController do
     api?: true
   ]
 
-  @block_params [
-    necessity_by_association:
-      %{
-        [miner: :names] => :optional,
-        :uncles => :optional,
-        :nephews => :optional,
-        :rewards => :optional,
-        :transactions => :optional,
-        :withdrawals => :optional
-      }
-      |> Map.merge(@chain_type_block_necessity_by_association),
-    api?: true
-  ]
-
   action_fallback(BlockScoutWeb.API.V2.FallbackController)
 
   @doc """
@@ -155,6 +150,33 @@ defmodule BlockScoutWeb.API.V2.BlockController do
     })
   end
 
+  @doc """
+    Function to handle GET requests to `/api/v2/blocks/arbitrum-batch/:batch_number` endpoint.
+    It renders the list of L2 blocks bound to the specified batch.
+  """
+  @spec arbitrum_batch(Plug.Conn.t(), any()) :: Plug.Conn.t()
+  def arbitrum_batch(conn, %{"batch_number" => batch_number} = params) do
+    full_options =
+      params
+      |> select_block_type()
+      |> Keyword.merge(paging_options(params))
+      |> Keyword.merge(@api_true)
+
+    {blocks, next_page} =
+      batch_number
+      |> ArbitrumReader.batch_blocks(full_options)
+      |> split_list_by_page()
+
+    next_page_params = next_page |> next_page_params(blocks, delete_parameters_from_next_page_params(params))
+
+    conn
+    |> put_status(200)
+    |> render(:blocks, %{
+      blocks: blocks |> maybe_preload_ens() |> maybe_preload_metadata(),
+      next_page_params: next_page_params
+    })
+  end
+
   @doc """
   Function to handle GET requests to `/api/v2/blocks/:block_hash_or_number/transactions` endpoint.
   """

apps/block_scout_web/lib/block_scout_web/controllers/api/v2/transaction_controller.ex

@@ -32,6 +32,7 @@ defmodule BlockScoutWeb.API.V2.TransactionController do
   alias BlockScoutWeb.MicroserviceInterfaces.TransactionInterpretation, as: TransactionInterpretationService
   alias BlockScoutWeb.Models.TransactionStateHelper
   alias Explorer.Chain
+  alias Explorer.Chain.Arbitrum.Reader, as: ArbitrumReader
   alias Explorer.Chain.Beacon.Reader, as: BeaconReader
   alias Explorer.Chain.{Hash, InternalTransaction, Transaction}
   alias Explorer.Chain.PolygonZkevm.Reader, as: PolygonZkevmReader
@@ -114,6 +115,14 @@ defmodule BlockScoutWeb.API.V2.TransactionController do
           |> Map.put(:zksync_prove_transaction, :optional)
           |> Map.put(:zksync_execute_transaction, :optional)
 
+        :arbitrum ->
+          necessity_by_association_with_actions
+          |> Map.put(:arbitrum_batch, :optional)
+          |> Map.put(:arbitrum_commitment_transaction, :optional)
+          |> Map.put(:arbitrum_confirmation_transaction, :optional)
+          |> Map.put(:arbitrum_message_to_l2, :optional)
+          |> Map.put(:arbitrum_message_from_l2, :optional)
+
         :suave ->
           necessity_by_association_with_actions
           |> Map.put(:logs, :optional)
@@ -194,7 +203,35 @@ defmodule BlockScoutWeb.API.V2.TransactionController do
     It renders the list of L2 transactions bound to the specified batch.
   """
   @spec zksync_batch(Plug.Conn.t(), map()) :: Plug.Conn.t()
-  def zksync_batch(conn, %{"batch_number" => batch_number} = params) do
+  def zksync_batch(conn, params) do
+    handle_batch_transactions(conn, params, &ZkSyncReader.batch_transactions/2)
+  end
+
+  @doc """
+    Function to handle GET requests to `/api/v2/transactions/arbitrum-batch/:batch_number` endpoint.
+    It renders the list of L2 transactions bound to the specified batch.
+  """
+  @spec arbitrum_batch(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def arbitrum_batch(conn, params) do
+    handle_batch_transactions(conn, params, &ArbitrumReader.batch_transactions/2)
+  end
+
+  # Processes and renders transactions for a specified batch into an HTTP response.
+  #
+  # This function retrieves a list of transactions for a given batch using a specified function,
+  # then extracts the transaction hashes. These hashes are used to retrieve the corresponding
+  # `Explorer.Chain.Transaction` records according to the given pagination options. It formats
+  # these transactions into an HTTP response.
+  #
+  # ## Parameters
+  # - `conn`: The connection object.
+  # - `params`: Parameters from the request, including the batch number.
+  # - `batch_transactions_fun`: A function to fetch transaction descriptions for the given batch.
+  #
+  # ## Returns
+  # - Updated connection object with the transactions data rendered.
+  @spec handle_batch_transactions(Plug.Conn.t(), map(), function()) :: Plug.Conn.t()
+  defp handle_batch_transactions(conn, %{"batch_number" => batch_number} = params, batch_transactions_fun) do
     full_options =
       [
         necessity_by_association: @transaction_necessity_by_association
@@ -206,13 +243,13 @@ defmodule BlockScoutWeb.API.V2.TransactionController do
     # it will require to re-implement all pagination logic existing in Explorer.Chain.Transaction
     # In order to simplify the code, all transaction are requested from the batch and then
     # only subset of them is returned from `hashes_to_transactions`.
-    raw_transactions_list =
+    transactions_plus_one =
       batch_number
-      |> ZkSyncReader.batch_transactions(api?: true)
-      |> Enum.map(fn tx -> tx.hash end)
+      |> batch_transactions_fun.(@api_true)
+      |> Enum.map(fn tx -> tx.tx_hash end)
       |> Chain.hashes_to_transactions(full_options)
 
-    {transactions, next_page} = split_list_by_page(raw_transactions_list)
+    {transactions, next_page} = split_list_by_page(transactions_plus_one)
     next_page_params = next_page |> next_page_params(transactions, delete_parameters_from_next_page_params(params))
 
     conn