feat: indexer for cross level messages on Arbitrum

apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/http.ex

@@ -163,11 +163,34 @@ defmodule EthereumJSONRPC.HTTP do
     {:error, resp}
   end
 
-  # restrict response to only those fields supported by the JSON-RPC 2.0 standard, which means that level of keys is
-  # validated, so we can indicate that with switch to atom keys.
-  def standardize_response(%{"jsonrpc" => "2.0" = jsonrpc, "id" => id} = unstandardized) do
+  @doc """
+    Standardizes responses to adhere to the JSON-RPC 2.0 standard.
+
+    This function adjusts responses to conform to JSON-RPC 2.0, ensuring the keys are atom-based
+    and that 'id', 'jsonrpc', 'result', and 'error' fields meet the protocol's requirements.
+    It also validates the mutual exclusivity of 'result' and 'error' fields within a response.
+
+    ## Parameters
+    - `unstandardized`: A map representing the response with string keys.
+
+    ## Returns
+    - A standardized map with atom keys and fields aligned with the JSON-RPC 2.0 standard, including
+      handling of possible mutual exclusivity errors between 'result' and 'error' fields.
+  """
+  @spec standardize_response(map()) :: %{
+          :id => nil | non_neg_integer(),
+          :jsonrpc => binary(),
+          optional(:error) => %{:code => integer(), :message => binary(), optional(:data) => any()},
+          optional(:result) => any()
+        }
+  def standardize_response(%{"jsonrpc" => "2.0" = jsonrpc} = unstandardized) do
+    # Avoid extracting `id` directly in the function declaration. Some endpoints
+    # do not adhere to standards and may omit the `id` in responses related to
+    # error scenarios. Consequently, the function call would fail during input
+    # argument matching.
+
     # Nethermind return string ids
-    id = quantity_to_integer(id)
+    id = quantity_to_integer(unstandardized["id"])
 
     standardized = %{jsonrpc: jsonrpc, id: id}
 
@@ -187,8 +210,21 @@ defmodule EthereumJSONRPC.HTTP do
     end
   end
 
-  # restrict error to only those fields supported by the JSON-RPC 2.0 standard, which means that level of keys is
-  # validated, so we can indicate that with switch to atom keys.
+  @doc """
+    Standardizes error responses to adhere to the JSON-RPC 2.0 standard.
+
+    This function converts a map containing error information into a format compliant
+    with the JSON-RPC 2.0 specification. It ensures the keys are atom-based and checks
+    for the presence of optional 'data' field, incorporating it if available.
+
+    ## Parameters
+    - `unstandardized`: A map representing the error with string keys: "code", "message"
+                        and "data" (optional).
+
+    ## Returns
+    - A standardized map with keys as atoms and fields aligned with the JSON-RPC 2.0 standard.
+  """
+  @spec standardize_error(map()) :: %{:code => integer(), :message => binary(), optional(:data) => any()}
   def standardize_error(%{"code" => code, "message" => message} = unstandardized)
       when is_integer(code) and is_binary(message) do
     standardized = %{code: code, message: message}

apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/transaction.ex

@@ -48,6 +48,13 @@ defmodule EthereumJSONRPC.Transaction do
                            ]
                          )
 
+    :arbitrum ->
+      @chain_type_fields quote(
+                           do: [
+                             request_id: non_neg_integer()
+                           ]
+                         )
+
     _ ->
       @chain_type_fields quote(do: [])
   end
@@ -509,6 +516,11 @@ defmodule EthereumJSONRPC.Transaction do
           })
         end
 
+      :arbitrum ->
+        put_if_present(elixir, params, [
+          {"requestId", :request_id}
+        ])
+
       _ ->
         params
     end
@@ -631,7 +643,7 @@ defmodule EthereumJSONRPC.Transaction do
     do: {"input", value}
 
   defp entry_to_elixir({key, quantity})
-       when key in ~w(gas gasPrice nonce r s standardV v value type maxPriorityFeePerGas maxFeePerGas maxFeePerBlobGas) and
+       when key in ~w(gas gasPrice nonce r s standardV v value type maxPriorityFeePerGas maxFeePerGas maxFeePerBlobGas requestId) and
               quantity != nil do
     {key, quantity_to_integer(quantity)}
   end

apps/explorer/config/dev.exs

@@ -31,6 +31,9 @@ config :explorer, Explorer.Repo.Suave, timeout: :timer.seconds(80)
 
 config :explorer, Explorer.Repo.Beacon, timeout: :timer.seconds(80)
 
+# Configure Arbitrum database
+config :explorer, Explorer.Repo.Arbitrum, timeout: :timer.seconds(80)
+
 config :explorer, Explorer.Repo.BridgedTokens, timeout: :timer.seconds(80)
 
 config :explorer, Explorer.Repo.Filecoin, timeout: :timer.seconds(80)

apps/explorer/config/prod.exs

@@ -48,6 +48,10 @@ config :explorer, Explorer.Repo.Beacon,
   prepare: :unnamed,
   timeout: :timer.seconds(60)
 
+config :explorer, Explorer.Repo.Arbitrum,
+  prepare: :unnamed,
+  timeout: :timer.seconds(60)
+
 config :explorer, Explorer.Repo.BridgedTokens,
   prepare: :unnamed,
   timeout: :timer.seconds(60)

apps/explorer/config/test.exs

@@ -62,6 +62,7 @@ for repo <- [
       Explorer.Repo.RSK,
       Explorer.Repo.Shibarium,
       Explorer.Repo.Suave,
+      Explorer.Repo.Arbitrum,
       Explorer.Repo.BridgedTokens,
       Explorer.Repo.Filecoin,
       Explorer.Repo.Stability,

apps/explorer/lib/explorer/application.ex

@@ -155,6 +155,7 @@ defmodule Explorer.Application do
         Explorer.Repo.RSK,
         Explorer.Repo.Shibarium,
         Explorer.Repo.Suave,
+        Explorer.Repo.Arbitrum,
         Explorer.Repo.BridgedTokens,
         Explorer.Repo.Filecoin,
         Explorer.Repo.Stability

apps/explorer/lib/explorer/chain.ex

@@ -2467,6 +2467,21 @@ defmodule Explorer.Chain do
     end
   end
 
+  @doc """
+    Finds the block number closest to a given timestamp, with a one-minute buffer, optionally
+    adjusting based on whether the block should be before or after the timestamp.
+
+    ## Parameters
+    - `given_timestamp`: The timestamp for which the closest block number is being sought.
+    - `closest`: A direction indicator (`:before` or `:after`) specifying whether the block number
+                returned should be before or after the given timestamp.
+    - `from_api`: A boolean flag indicating whether to use the replica database or the primary one
+                  for the query.
+
+    ## Returns
+    - `{:ok, block_number}` where `block_number` is the block number closest to the specified timestamp.
+    - `{:error, :not_found}` if no block is found within the specified criteria.
+  """
   @spec timestamp_to_block_number(DateTime.t(), :before | :after, boolean()) ::
           {:ok, Block.block_number()} | {:error, :not_found}
   def timestamp_to_block_number(given_timestamp, closest, from_api) do
@@ -3299,6 +3314,22 @@ defmodule Explorer.Chain do
 
   def limit_showing_transactions, do: @limit_showing_transactions
 
+  @doc """
+    Dynamically joins and preloads associations in a query based on necessity.
+
+    This function adjusts the provided Ecto query to include joins for associations. It supports
+    both optional and required joins. Optional joins use the `preload` function to fetch associations
+    without enforcing their presence. Required joins ensure the association exists.
+
+    ## Parameters
+    - `query`: The initial Ecto query.
+    - `associations`: A single association or a tuple with nested association preloads.
+    - `necessity`: Specifies if the association is `:optional` or `:required`.
+
+    ## Returns
+    - The modified query with the specified associations joined according to the defined necessity.
+  """
+  @spec join_association(atom() | Ecto.Query.t(), [{atom(), atom()}], :optional | :required) :: Ecto.Query.t()
   def join_association(query, [{association, nested_preload}], necessity)
       when is_atom(association) and is_atom(nested_preload) do
     case necessity do
@@ -3316,6 +3347,7 @@ defmodule Explorer.Chain do
     end
   end
 
+  @spec join_association(atom() | Ecto.Query.t(), atom(), :optional | :required) :: Ecto.Query.t()
   def join_association(query, association, necessity) do
     case necessity do
       :optional ->
@@ -3326,10 +3358,23 @@ defmodule Explorer.Chain do
     end
   end
 
-  @spec join_associations(atom() | Ecto.Query.t(), map) :: Ecto.Query.t()
   @doc """
-    Function to preload entities associated with selected in provided query items
+    Applies dynamic joins to a query based on provided association necessities.
+
+    This function iterates over a map of associations with their required join types, either
+    `:optional` or `:required`, and applies the corresponding joins to the given query.
+
+    More info is available on https://hexdocs.pm/ecto/Ecto.Query.html#preload/3
+
+    ## Parameters
+    - `query`: The base query to which associations will be joined.
+    - `necessity_by_association`: A map specifying each association and its necessity
+      (`:optional` or `:required`).
+
+    ## Returns
+    - The query with all specified associations joined according to their necessity.
   """
+  @spec join_associations(atom() | Ecto.Query.t(), %{any() => :optional | :required}) :: Ecto.Query.t()
   def join_associations(query, necessity_by_association) when is_map(necessity_by_association) do
     Enum.reduce(necessity_by_association, query, fn {association, join}, acc_query ->
       join_association(acc_query, association, join)

apps/explorer/lib/explorer/chain/arbitrum/batch_block.ex

@@ -0,0 +1,53 @@
+defmodule Explorer.Chain.Arbitrum.BatchBlock do
+  @moduledoc """
+    Models a list of blocks related to a batch for Arbitrum.
+
+    Changes in the schema should be reflected in the bulk import module:
+    - Explorer.Chain.Import.Runner.Arbitrum.BatchBlocks
+
+    Migrations:
+    - Explorer.Repo.Arbitrum.Migrations.CreateArbitrumTables
+  """
+
+  use Explorer.Schema
+
+  alias Explorer.Chain.Arbitrum.{L1Batch, LifecycleTransaction}
+
+  @optional_attrs ~w(confirm_id)a
+
+  @required_attrs ~w(batch_number block_number)a
+
+  @type t :: %__MODULE__{
+          batch_number: non_neg_integer(),
+          batch: %Ecto.Association.NotLoaded{} | L1Batch.t() | nil,
+          block_number: non_neg_integer(),
+          confirm_id: non_neg_integer() | nil,
+          confirm_transaction: %Ecto.Association.NotLoaded{} | LifecycleTransaction.t() | nil
+        }
+
+  @primary_key {:block_number, :integer, autogenerate: false}
+  schema "arbitrum_batch_l2_blocks" do
+    belongs_to(:batch, L1Batch, foreign_key: :batch_number, references: :number, type: :integer)
+
+    belongs_to(:confirm_transaction, LifecycleTransaction,
+      foreign_key: :confirm_id,
+      references: :id,
+      type: :integer
+    )
+
+    timestamps()
+  end
+
+  @doc """
+    Validates that the `attrs` are valid.
+  """
+  @spec changeset(Ecto.Schema.t(), map()) :: Ecto.Schema.t()
+  def changeset(%__MODULE__{} = items, attrs \\ %{}) do
+    items
+    |> cast(attrs, @required_attrs ++ @optional_attrs)
+    |> validate_required(@required_attrs)
+    |> foreign_key_constraint(:batch_number)
+    |> foreign_key_constraint(:confirm_id)
+    |> unique_constraint(:block_number)
+  end
+end

apps/explorer/lib/explorer/chain/arbitrum/batch_transaction.ex

@@ -0,0 +1,52 @@
+defmodule Explorer.Chain.Arbitrum.BatchTransaction do
+  @moduledoc """
+    Models a list of transactions related to a batch for Arbitrum.
+
+    Changes in the schema should be reflected in the bulk import module:
+    - Explorer.Chain.Import.Runner.Arbitrum.BatchTransactions
+
+    Migrations:
+    - Explorer.Repo.Arbitrum.Migrations.CreateArbitrumTables
+  """
+
+  use Explorer.Schema
+
+  alias Explorer.Chain.Arbitrum.L1Batch
+  alias Explorer.Chain.{Hash, Transaction}
+
+  @required_attrs ~w(batch_number tx_hash)a
+
+  @type t :: %__MODULE__{
+          batch_number: non_neg_integer(),
+          batch: %Ecto.Association.NotLoaded{} | L1Batch.t() | nil,
+          tx_hash: Hash.t(),
+          l2_transaction: %Ecto.Association.NotLoaded{} | Transaction.t() | nil
+        }
+
+  @primary_key false
+  schema "arbitrum_batch_l2_transactions" do
+    belongs_to(:batch, L1Batch, foreign_key: :batch_number, references: :number, type: :integer)
+
+    belongs_to(:l2_transaction, Transaction,
+      foreign_key: :tx_hash,
+      primary_key: true,
+      references: :hash,
+      type: Hash.Full
+    )
+
+    timestamps()
+  end
+
+  @doc """
+    Validates that the `attrs` are valid.
+  """
+  @spec changeset(Ecto.Schema.t(), map()) :: Ecto.Schema.t()
+  def changeset(%__MODULE__{} = transactions, attrs \\ %{}) do
+    transactions
+    |> cast(attrs, @required_attrs)
+    |> validate_required(@required_attrs)
+    |> foreign_key_constraint(:batch_number)
+    |> foreign_key_constraint(:block_hash)
+    |> unique_constraint(:tx_hash)
+  end
+end

apps/explorer/lib/explorer/chain/arbitrum/l1_batch.ex

@@ -0,0 +1,62 @@
+defmodule Explorer.Chain.Arbitrum.L1Batch do
+  @moduledoc """
+    Models an L1 batch for Arbitrum.
+
+    Changes in the schema should be reflected in the bulk import module:
+    - Explorer.Chain.Import.Runner.Arbitrum.L1Batches
+
+    Migrations:
+    - Explorer.Repo.Arbitrum.Migrations.CreateArbitrumTables
+  """
+
+  use Explorer.Schema
+
+  alias Explorer.Chain.{
+    Block,
+    Hash
+  }
+
+  alias Explorer.Chain.Arbitrum.LifecycleTransaction
+
+  @required_attrs ~w(number tx_count start_block end_block before_acc after_acc commit_id)a
+
+  @type t :: %__MODULE__{
+          number: non_neg_integer(),
+          tx_count: non_neg_integer(),
+          start_block: Block.block_number(),
+          end_block: Block.block_number(),
+          before_acc: Hash.t(),
+          after_acc: Hash.t(),
+          commit_id: non_neg_integer(),
+          commit_transaction: %Ecto.Association.NotLoaded{} | LifecycleTransaction.t() | nil
+        }
+
+  @primary_key {:number, :integer, autogenerate: false}
+  schema "arbitrum_l1_batches" do
+    field(:tx_count, :integer)
+    field(:start_block, :integer)
+    field(:end_block, :integer)
+    field(:before_acc, Hash.Full)
+    field(:after_acc, Hash.Full)
+
+    belongs_to(:commit_transaction, LifecycleTransaction,
+      foreign_key: :commit_id,
+      references: :id,
+      type: :integer
+    )
+
+    timestamps()
+  end
+
+  @doc """
+    Validates that the `attrs` are valid.
+  """
+  @spec changeset(Ecto.Schema.t(), map()) :: Ecto.Schema.t()
+  def changeset(%__MODULE__{} = batches, attrs \\ %{}) do
+    batches
+    |> cast(attrs, @required_attrs)
+    |> validate_required(@required_attrs)
+    |> foreign_key_constraint(:commit_id)
+    |> unique_constraint(:number)
+  end
+end