feat: Add GraphQL API endpoints for Signet orders and fills

Phase 2 of ENG-1876: Signet Order Tracking and Indexing

This adds GraphQL API support for querying Signet orders and fills:

**New GraphQL Types (apps/block_scout_web/lib/block_scout_web/graphql/signet/):**
- schema/types.ex: signet_order and signet_fill node objects
- schema/query_fields.ex: Query fields with pagination support

**New Resolvers:**
- resolvers/order.ex: get_by and list resolvers for orders
- resolvers/fill.ex: get_by and list resolvers for fills

**New Explorer Module (apps/explorer/lib/explorer/graphql/signet.ex):**
- get_order/2: Fetch single order by transaction_hash + log_index
- orders_query/1: Paginated orders with block range filters
- get_fill/3: Fetch single fill by chain_type + transaction_hash + log_index
- fills_query/1: Paginated fills with chain_type and block range filters

**GraphQL Queries:**
- signet_order(transaction_hash, log_index): Get single order
- signet_orders(first, after, block_number_gte, block_number_lte): Paginated orders
- signet_fill(chain_type, transaction_hash, log_index): Get single fill
- signet_fills(first, after, chain_type, block_number_gte, block_number_lte): Paginated fills

Uses compile-time chain_type check to conditionally include Signet schema
when CHAIN_TYPE=signet, following Blockscout's chain-specific extension patterns.

Builds on PR #2 (Phase 1 data models and indexer).

Closes ENG-1876

Author: init4samwise

apps/block_scout_web/lib/block_scout_web/graphql/schema.ex

@@ -3,7 +3,7 @@ defmodule BlockScoutWeb.GraphQL.Schema do
 
   use Absinthe.Schema
   use Absinthe.Relay.Schema, :modern
-  use Utils.CompileTimeEnvHelper, chain_identity: [:explorer, :chain_identity]
+  use Utils.CompileTimeEnvHelper, chain_identity: [:explorer, :chain_identity], chain_type: [:explorer, :chain_type]
 
   alias Absinthe.Middleware.Dataloader, as: AbsintheDataloaderMiddleware
   alias Absinthe.Plugin, as: AbsinthePlugin
@@ -23,12 +23,21 @@ defmodule BlockScoutWeb.GraphQL.Schema do
   alias Explorer.Chain.TokenTransfer, as: ExplorerChainTokenTransfer
   alias Explorer.Chain.Transaction, as: ExplorerChainTransaction
 
+  if @chain_type == :signet do
+    alias Explorer.Chain.Signet.Order, as: ExplorerChainSignetOrder
+    alias Explorer.Chain.Signet.Fill, as: ExplorerChainSignetFill
+  end
+
   import_types(BlockScoutWeb.GraphQL.Schema.Types)
 
   if @chain_identity == {:optimism, :celo} do
     import_types(BlockScoutWeb.GraphQL.Celo.Schema.Types)
   end
 
+  if @chain_type == :signet do
+    import_types(BlockScoutWeb.GraphQL.Signet.Schema.Types)
+  end
+
   node interface do
     resolve_type(fn
       %ExplorerChainInternalTransaction{}, _ ->
@@ -114,6 +123,13 @@ defmodule BlockScoutWeb.GraphQL.Schema do
 
       QueryFields.generate()
     end
+
+    if @chain_type == :signet do
+      require BlockScoutWeb.GraphQL.Signet.QueryFields
+      alias BlockScoutWeb.GraphQL.Signet.QueryFields, as: SignetQueryFields
+
+      SignetQueryFields.generate()
+    end
   end
 
   subscription do

apps/block_scout_web/lib/block_scout_web/graphql/signet/resolvers/fill.ex

@@ -0,0 +1,50 @@
+defmodule BlockScoutWeb.GraphQL.Signet.Resolvers.Fill do
+  @moduledoc """
+  Resolvers for Signet fills, used in the Signet GraphQL schema.
+  """
+
+  alias Absinthe.Relay.Connection
+  alias Explorer.Chain
+  alias Explorer.GraphQL.Signet, as: GraphQL
+  alias Explorer.Repo
+
+  @doc """
+  Gets a single fill by chain type, transaction hash, and log index.
+  """
+  def get_by(_parent, %{chain_type: chain_type_string, transaction_hash: hash_string, log_index: log_index}, _resolution) do
+    with {:ok, hash} <- Chain.string_to_full_hash(hash_string),
+         {:ok, chain_type} <- parse_chain_type(chain_type_string) do
+      case GraphQL.get_fill(chain_type, hash, log_index) do
+        nil -> {:error, "Fill not found"}
+        fill -> {:ok, fill}
+      end
+    end
+  end
+
+  @doc """
+  Lists fills with optional filters and pagination.
+  """
+  def list(_parent, args, _resolution) do
+    args
+    |> maybe_parse_chain_type_filter()
+    |> GraphQL.fills_query()
+    |> Connection.from_query(&Repo.all/1, args, options(args))
+  end
+
+  defp parse_chain_type("rollup"), do: {:ok, :rollup}
+  defp parse_chain_type("host"), do: {:ok, :host}
+  defp parse_chain_type(_), do: {:error, "Invalid chain_type. Must be 'rollup' or 'host'"}
+
+  defp maybe_parse_chain_type_filter(%{chain_type: chain_type_string} = args) do
+    case parse_chain_type(chain_type_string) do
+      {:ok, chain_type} -> Map.put(args, :chain_type, chain_type)
+      {:error, _} -> args
+    end
+  end
+
+  defp maybe_parse_chain_type_filter(args), do: args
+
+  defp options(%{before: _}), do: []
+  defp options(%{count: count}), do: [count: count]
+  defp options(_), do: []
+end

apps/block_scout_web/lib/block_scout_web/graphql/signet/resolvers/order.ex

@@ -0,0 +1,35 @@
+defmodule BlockScoutWeb.GraphQL.Signet.Resolvers.Order do
+  @moduledoc """
+  Resolvers for Signet orders, used in the Signet GraphQL schema.
+  """
+
+  alias Absinthe.Relay.Connection
+  alias Explorer.Chain
+  alias Explorer.GraphQL.Signet, as: GraphQL
+  alias Explorer.Repo
+
+  @doc """
+  Gets a single order by transaction hash and log index.
+  """
+  def get_by(_parent, %{transaction_hash: hash_string, log_index: log_index}, _resolution) do
+    with {:ok, hash} <- Chain.string_to_full_hash(hash_string) do
+      case GraphQL.get_order(hash, log_index) do
+        nil -> {:error, "Order not found"}
+        order -> {:ok, order}
+      end
+    end
+  end
+
+  @doc """
+  Lists orders with optional filters and pagination.
+  """
+  def list(_parent, args, _resolution) do
+    args
+    |> GraphQL.orders_query()
+    |> Connection.from_query(&Repo.all/1, args, options(args))
+  end
+
+  defp options(%{before: _}), do: []
+  defp options(%{count: count}), do: [count: count]
+  defp options(_), do: []
+end

apps/block_scout_web/lib/block_scout_web/graphql/signet/schema/query_fields.ex

@@ -0,0 +1,62 @@
+defmodule BlockScoutWeb.GraphQL.Signet.QueryFields do
+  @moduledoc """
+  Query fields for the Signet schema.
+  """
+
+  alias BlockScoutWeb.GraphQL.Signet.Resolvers.{Fill, Order}
+
+  use Absinthe.Schema.Notation
+  use Absinthe.Relay.Schema, :modern
+
+  defmacro generate do
+    quote do
+      @desc "Gets a Signet order by transaction hash and log index."
+      field :signet_order, :signet_order do
+        arg(:transaction_hash, non_null(:full_hash))
+        arg(:log_index, non_null(:integer))
+
+        resolve(&Order.get_by/3)
+      end
+
+      @desc "Gets Signet orders with pagination."
+      connection field(:signet_orders, node_type: :signet_order) do
+        arg(:count, :integer)
+        arg(:block_number_gte, :integer)
+        arg(:block_number_lte, :integer)
+
+        resolve(&Order.list/3)
+
+        complexity(fn
+          %{first: first}, child_complexity -> first * child_complexity
+          %{last: last}, child_complexity -> last * child_complexity
+          %{}, _child_complexity -> 0
+        end)
+      end
+
+      @desc "Gets a Signet fill by chain type, transaction hash, and log index."
+      field :signet_fill, :signet_fill do
+        arg(:chain_type, non_null(:string))
+        arg(:transaction_hash, non_null(:full_hash))
+        arg(:log_index, non_null(:integer))
+
+        resolve(&Fill.get_by/3)
+      end
+
+      @desc "Gets Signet fills with pagination."
+      connection field(:signet_fills, node_type: :signet_fill) do
+        arg(:count, :integer)
+        arg(:chain_type, :string)
+        arg(:block_number_gte, :integer)
+        arg(:block_number_lte, :integer)
+
+        resolve(&Fill.list/3)
+
+        complexity(fn
+          %{first: first}, child_complexity -> first * child_complexity
+          %{last: last}, child_complexity -> last * child_complexity
+          %{}, _child_complexity -> 0
+        end)
+      end
+    end
+  end
+end

apps/block_scout_web/lib/block_scout_web/graphql/signet/schema/types.ex

@@ -0,0 +1,64 @@
+defmodule BlockScoutWeb.GraphQL.Signet.Schema.Types do
+  @moduledoc """
+  GraphQL types for Signet orders and fills.
+  """
+
+  use Absinthe.Schema.Notation
+  use Absinthe.Relay.Schema.Notation, :modern
+
+  @desc """
+  Represents a Signet cross-chain order from the RollupOrders contract.
+
+  Orders specify inputs (tokens offered by the maker) and outputs (tokens
+  expected in return). The chainId in outputs represents the DESTINATION
+  chain where assets should be delivered.
+  """
+  node object(:signet_order, id_fetcher: &signet_order_id_fetcher/2) do
+    field(:transaction_hash, :full_hash)
+    field(:log_index, :integer)
+    field(:block_number, :integer)
+    field(:deadline, :integer)
+    field(:inputs_json, :string)
+    field(:outputs_json, :string)
+    field(:sweep_recipient, :address_hash)
+    field(:sweep_token, :address_hash)
+    field(:sweep_amount, :decimal)
+    field(:inserted_at, :datetime)
+  end
+
+  @desc """
+  Represents a Signet fill event from RollupOrders or HostOrders contracts.
+
+  Fills record the execution of orders. The chainId in outputs represents
+  the ORIGIN chain where the order was created, not where the fill occurred.
+  """
+  node object(:signet_fill, id_fetcher: &signet_fill_id_fetcher/2) do
+    field(:chain_type, :string)
+    field(:transaction_hash, :full_hash)
+    field(:log_index, :integer)
+    field(:block_number, :integer)
+    field(:outputs_json, :string)
+    field(:inserted_at, :datetime)
+  end
+
+  connection(node_type: :signet_order)
+  connection(node_type: :signet_fill)
+
+  defp signet_order_id_fetcher(%{transaction_hash: transaction_hash, log_index: log_index}, _) do
+    Jason.encode!(%{
+      transaction_hash: to_string(transaction_hash),
+      log_index: log_index
+    })
+  end
+
+  defp signet_fill_id_fetcher(
+         %{chain_type: chain_type, transaction_hash: transaction_hash, log_index: log_index},
+         _
+       ) do
+    Jason.encode!(%{
+      chain_type: to_string(chain_type),
+      transaction_hash: to_string(transaction_hash),
+      log_index: log_index
+    })
+  end
+end

apps/explorer/lib/explorer/graphql/signet.ex

@@ -0,0 +1,128 @@
+defmodule Explorer.GraphQL.Signet do
+  @moduledoc """
+  Defines Ecto queries to fetch Signet order and fill data for the GraphQL schema.
+
+  Includes functions to construct queries for orders and fills, supporting
+  pagination and filtering by block range and chain type.
+  """
+
+  import Ecto.Query, only: [from: 2, order_by: 3, where: 3]
+
+  alias Explorer.Chain.Hash
+  alias Explorer.Chain.Signet.{Fill, Order}
+  alias Explorer.Repo
+
+  @doc """
+  Gets a single order by transaction hash and log index.
+
+  ## Parameters
+    - transaction_hash: the full transaction hash
+    - log_index: the log index within the transaction
+
+  ## Returns
+    - Order struct or nil
+  """
+  @spec get_order(Hash.Full.t(), integer()) :: Order.t() | nil
+  def get_order(transaction_hash, log_index) do
+    Repo.one(
+      from(o in Order,
+        where: o.transaction_hash == ^transaction_hash and o.log_index == ^log_index
+      )
+    )
+  end
+
+  @doc """
+  Constructs a query for orders with optional filters.
+
+  ## Parameters
+    - args: Map with optional filters:
+      - block_number_gte: minimum block number
+      - block_number_lte: maximum block number
+
+  ## Returns
+    - Ecto query
+  """
+  @spec orders_query(map()) :: Ecto.Query.t()
+  def orders_query(args \\ %{}) do
+    from(o in Order, as: :order)
+    |> maybe_filter_block_range(args, :order)
+    |> order_by([order: o], desc: o.block_number, desc: o.log_index)
+  end
+
+  @doc """
+  Gets a single fill by chain type, transaction hash, and log index.
+
+  ## Parameters
+    - chain_type: :rollup or :host
+    - transaction_hash: the full transaction hash
+    - log_index: the log index within the transaction
+
+  ## Returns
+    - Fill struct or nil
+  """
+  @spec get_fill(atom(), Hash.Full.t(), integer()) :: Fill.t() | nil
+  def get_fill(chain_type, transaction_hash, log_index) do
+    Repo.one(
+      from(f in Fill,
+        where:
+          f.chain_type == ^chain_type and
+            f.transaction_hash == ^transaction_hash and
+            f.log_index == ^log_index
+      )
+    )
+  end
+
+  @doc """
+  Constructs a query for fills with optional filters.
+
+  ## Parameters
+    - args: Map with optional filters:
+      - chain_type: :rollup or :host atom
+      - block_number_gte: minimum block number
+      - block_number_lte: maximum block number
+
+  ## Returns
+    - Ecto query
+  """
+  @spec fills_query(map()) :: Ecto.Query.t()
+  def fills_query(args \\ %{}) do
+    from(f in Fill, as: :fill)
+    |> maybe_filter_chain_type(args)
+    |> maybe_filter_block_range(args, :fill)
+    |> order_by([fill: f], desc: f.block_number, desc: f.log_index)
+  end
+
+  # Private helper to filter by chain_type
+  defp maybe_filter_chain_type(query, %{chain_type: chain_type}) when chain_type in [:rollup, :host] do
+    where(query, [fill: f], f.chain_type == ^chain_type)
+  end
+
+  defp maybe_filter_chain_type(query, _), do: query
+
+  # Private helper to filter by block range
+  defp maybe_filter_block_range(query, args, binding) do
+    query
+    |> maybe_filter_block_gte(args, binding)
+    |> maybe_filter_block_lte(args, binding)
+  end
+
+  defp maybe_filter_block_gte(query, %{block_number_gte: block_number}, :order) do
+    where(query, [order: o], o.block_number >= ^block_number)
+  end
+
+  defp maybe_filter_block_gte(query, %{block_number_gte: block_number}, :fill) do
+    where(query, [fill: f], f.block_number >= ^block_number)
+  end
+
+  defp maybe_filter_block_gte(query, _, _), do: query
+
+  defp maybe_filter_block_lte(query, %{block_number_lte: block_number}, :order) do
+    where(query, [order: o], o.block_number <= ^block_number)
+  end
+
+  defp maybe_filter_block_lte(query, %{block_number_lte: block_number}, :fill) do
+    where(query, [fill: f], f.block_number <= ^block_number)
+  end
+
+  defp maybe_filter_block_lte(query, _, _), do: query
+end