fix: Rollback token hash by symbol logic in advanced filters (blockscout#14401)

Author: vbaranov

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### 🐛 Bug Fixes
 
-- Declare missing OpenAPI params for advanced-filters endpoint ([#14399](https://github.com/blockscout/blockscout/issues/14399))
+- Declare missing OpenAPI params for advanced-filters endpoint ([#14401](https://github.com/blockscout/blockscout/pull/14401), [#14399](https://github.com/blockscout/blockscout/issues/14399))
 
 ## 11.1.0
 

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

@@ -505,26 +505,6 @@ defmodule BlockScoutWeb.API.V2.AdvancedFilterController do
   end
 
   defp extract_filters(params) do
-    address_token_hashes =
-      params[:token_contract_address_hashes_to_include]
-      |> prepare_include_exclude_address_hashes(
-        params[:token_contract_address_hashes_to_exclude],
-        &prepare_token_address_hash/1
-      )
-
-    symbol_token_hashes =
-      prepare_include_exclude_address_hashes_from_symbols(
-        params[:token_contract_symbols_to_include],
-        params[:token_contract_symbols_to_exclude]
-      )
-
-    token_contract_address_hashes =
-      merge_token_hashes(address_token_hashes, symbol_token_hashes)
-      |> Enum.map(fn
-        {key, value} when is_list(value) -> {key, Enum.take(value, @tokens_filter_limit)}
-        key_value -> key_value
-      end)
-
     [
       transaction_types: prepare_transaction_types(params[:transaction_types]),
       methods: merge_methods(prepare_methods(params[:methods]), prepare_methods_from_names(params[:methods_names])),
@@ -543,7 +523,16 @@ defmodule BlockScoutWeb.API.V2.AdvancedFilterController do
         ),
       address_relation: prepare_address_relation(params[:address_relation]),
       amount: prepare_amount(params[:amount_from], params[:amount_to]),
-      token_contract_address_hashes: token_contract_address_hashes
+      token_contract_address_hashes:
+        params[:token_contract_address_hashes_to_include]
+        |> prepare_include_exclude_address_hashes(
+          params[:token_contract_address_hashes_to_exclude],
+          &prepare_token_address_hash/1
+        )
+        |> Enum.map(fn
+          {key, value} when is_list(value) -> {key, Enum.take(value, @tokens_filter_limit)}
+          key_value -> key_value
+        end)
     ]
   end
 
@@ -640,42 +629,6 @@ defmodule BlockScoutWeb.API.V2.AdvancedFilterController do
     end
   end
 
-  defp prepare_include_exclude_address_hashes_from_symbols(include_symbols, exclude_symbols) do
-    [
-      include: resolve_symbols_to_address_hashes(include_symbols),
-      exclude: resolve_symbols_to_address_hashes(exclude_symbols)
-    ]
-  end
-
-  defp resolve_symbols_to_address_hashes(symbols_str) when is_binary(symbols_str) do
-    case symbols_str |> String.split(",") |> Enum.map(&String.trim/1) |> Enum.reject(&(&1 == "")) do
-      [] ->
-        nil
-
-      symbols ->
-        symbols
-        |> Token.get_by_symbols(@api_true)
-        |> Enum.map(& &1.contract_address_hash)
-    end
-  end
-
-  defp resolve_symbols_to_address_hashes(_), do: nil
-
-  defp merge_token_hashes(address_based, symbol_based) do
-    [:include, :exclude]
-    |> Enum.map(fn key ->
-      merged =
-        case {address_based[key], symbol_based[key]} do
-          {nil, nil} -> nil
-          {a, nil} -> a
-          {nil, b} -> b
-          {a, b} -> Enum.uniq(a ++ b)
-        end
-
-      {key, merged}
-    end)
-  end
-
   defp prepare_address_relation(relation) do
     case relation && String.downcase(relation) do
       r when r in [nil, "or"] -> :or

apps/block_scout_web/test/block_scout_web/controllers/api/v2/advanced_filter_controller_test.exs

@@ -632,74 +632,6 @@ defmodule BlockScoutWeb.API.V2.AdvancedFilterControllerTest do
              end)
     end
 
-    test "filter by token_contract_symbols_to_include", %{conn: conn} do
-      token_a = insert(:token, symbol: "SYMINCL_A")
-      token_b = insert(:token, symbol: "SYMINCL_B")
-      token_c = insert(:token, symbol: "SYMINCL_C")
-
-      transaction = :transaction |> insert() |> with_block()
-
-      [token_a, token_b, token_c, token_a, token_b, token_c]
-      |> Enum.with_index()
-      |> Enum.each(fn {token, i} ->
-        insert(:token_transfer,
-          token_contract_address: token.contract_address,
-          transaction: transaction,
-          block_number: transaction.block_number,
-          log_index: i
-        )
-      end)
-
-      request =
-        get(conn, "/api/v2/advanced-filters", %{
-          "token_contract_symbols_to_include" => "SYMINCL_A,SYMINCL_B"
-        })
-
-      assert response = json_response(request, 200)
-
-      # Include filter: only token transfers whose contract matches — the parent
-      # transaction itself has no token contract so it is excluded.
-      assert Enum.count(response["items"]) == 4
-
-      assert Enum.all?(response["items"], fn item ->
-               item["token"]["symbol"] in ["SYMINCL_A", "SYMINCL_B"]
-             end)
-    end
-
-    test "filter by token_contract_symbols_to_exclude", %{conn: conn} do
-      token_a = insert(:token, symbol: "SYMEXCL_A")
-      token_b = insert(:token, symbol: "SYMEXCL_B")
-      token_c = insert(:token, symbol: "SYMEXCL_C")
-
-      transaction = :transaction |> insert() |> with_block()
-
-      [token_a, token_b, token_c, token_a, token_b, token_c]
-      |> Enum.with_index()
-      |> Enum.each(fn {token, i} ->
-        insert(:token_transfer,
-          token_contract_address: token.contract_address,
-          transaction: transaction,
-          block_number: transaction.block_number,
-          log_index: i
-        )
-      end)
-
-      request =
-        get(conn, "/api/v2/advanced-filters", %{
-          "token_contract_symbols_to_exclude" => "SYMEXCL_C"
-        })
-
-      assert response = json_response(request, 200)
-
-      # Exclude filter: 4 token transfers (A×2 + B×2) plus the parent transaction
-      # itself (which has no token contract and is therefore not excluded).
-      assert Enum.count(response["items"]) == 5
-
-      assert Enum.all?(response["items"], fn item ->
-               is_nil(item["token"]) or item["token"]["symbol"] != "SYMEXCL_C"
-             end)
-    end
-
     test "filter by age", %{conn: conn} do
       [_, transaction_a, _, transaction_b, _] =
         for i <- 0..4 do

apps/explorer/lib/explorer/chain/token.ex

@@ -468,16 +468,6 @@ defmodule Explorer.Chain.Token do
     |> Chain.select_repo(options).all()
   end
 
-  @doc """
-    Gets tokens whose symbol matches any of the given symbols (case-sensitive).
-  """
-  @spec get_by_symbols([String.t()], [Chain.api?()]) :: [__MODULE__.t()]
-  def get_by_symbols(symbols, options) do
-    __MODULE__
-    |> where([t], t.symbol in ^symbols)
-    |> Chain.select_repo(options).all()
-  end
-
   @doc """
     For usage in Indexer.Fetcher.TokenInstance.SanitizeERC721
   """

cspell.json

@@ -680,8 +680,6 @@
         "sushiswap",
         "swal",
         "sweetalert",
-        "SYMEXCL",
-        "SYMINCL",
         "Synthereum",
         "tabindex",
         "tablist",