[TA-4404]: Fix indexer token precompile sync

apps/indexer/lib/indexer/fetcher/coin_balance/helper.ex

@@ -12,6 +12,8 @@ defmodule Indexer.Fetcher.CoinBalance.Helper do
   alias Explorer.Chain.Cache.{Accounts, BlockNumber}
   alias Explorer.Chain.Hash
   alias Indexer.BufferedTask
+  alias Indexer.TokenBalances
+  alias Indexer.Transformers.CoinToTokenBalanceTransformer
 
   @doc false
   # credo:disable-for-next-line Credo.Check.Design.DuplicatedCode
@@ -97,17 +99,29 @@ defmodule Indexer.Fetcher.CoinBalance.Helper do
     value_fetched_at = DateTime.utc_now()
 
     importable_balances_params = Enum.map(params_list, &Map.put(&1, :value_fetched_at, value_fetched_at))
-
     json_rpc_named_arguments = Application.get_env(:explorer, :json_rpc_named_arguments)
-
     importable_balances_daily_params = balances_daily_params(params_list, json_rpc_named_arguments)
-
     addresses_params = balances_params_to_address_params(importable_balances_params)
 
+    transformed_params = CoinToTokenBalanceTransformer.transform_address_coin_balances(importable_balances_params)
+
+    {coin_balance_entries, token_balance_entries} =
+      Enum.split_with(transformed_params, fn
+        {:address_token_balance, _} -> false
+        _ -> true
+      end)
+
+    token_balance_params =
+      Enum.map(token_balance_entries, fn {:address_token_balance, token_balance} -> token_balance end)
+
+    current_token_balance_entries = TokenBalances.to_address_current_token_balances(token_balance_params)
+
     Chain.import(%{
       addresses: %{params: addresses_params, with: :balance_changeset},
-      address_coin_balances: %{params: importable_balances_params},
+      address_coin_balances: %{params: coin_balance_entries},
       address_coin_balances_daily: %{params: importable_balances_daily_params},
+      address_token_balances: %{params: token_balance_params},
+      address_current_token_balances: %{params: current_token_balance_entries},
       broadcast: broadcast_type
     })
   end
@@ -205,7 +219,7 @@ defmodule Indexer.Fetcher.CoinBalance.Helper do
     end)
   end
 
-  defp balances_daily_params(params_list, json_rpc_named_arguments) do
+  def balances_daily_params(params_list, json_rpc_named_arguments) do
     block_timestamp_map = block_timestamp_map(params_list, json_rpc_named_arguments)
 
     params_list

apps/indexer/lib/indexer/fetcher/token_balance.ex

@@ -25,6 +25,8 @@ defmodule Indexer.Fetcher.TokenBalance do
   alias Indexer.{BufferedTask, TokenBalances, Tracer}
   alias Indexer.Fetcher.TokenBalance.Supervisor, as: TokenBalanceSupervisor
 
+  import Indexer.Fetcher.CoinBalance.Helper, only: [balances_daily_params: 2]
+
   @behaviour BufferedTask
 
   @default_max_batch_size 100
@@ -210,12 +212,31 @@ defmodule Indexer.Fetcher.TokenBalance do
     addresses_params = format_and_filter_address_params(token_balances_params)
     formatted_token_balances_params = format_and_filter_token_balance_params(token_balances_params)
 
+    transformed_params =
+      Indexer.Transformers.TokenToCoinBalanceTransformer.transform_address_token_balances(
+        formatted_token_balances_params
+      )
+
+    {token_balance_entries, coin_balance_entries} =
+      Enum.split_with(transformed_params, fn
+        {:address_coin_balance, _} -> false
+        _ -> true
+      end)
+
+    current_token_balances = TokenBalances.to_address_current_token_balances(token_balance_entries)
+
+    coin_balance_params =
+      Enum.map(coin_balance_entries, fn {:address_coin_balance, coin_balance} -> coin_balance end)
+
+    json_rpc_named_arguments = Application.get_env(:explorer, :json_rpc_named_arguments)
+    daily_coin_balance_entries = balances_daily_params(coin_balance_params, json_rpc_named_arguments)
+
     import_params = %{
-      addresses: %{params: addresses_params},
-      address_token_balances: %{params: formatted_token_balances_params},
-      address_current_token_balances: %{
-        params: TokenBalances.to_address_current_token_balances(formatted_token_balances_params)
-      },
+      addresses: %{params: addresses_params, with: :balance_changeset},
+      address_token_balances: %{params: token_balance_entries},
+      address_current_token_balances: %{params: current_token_balances},
+      address_coin_balances: %{params: coin_balance_params},
+      address_coin_balances_daily: %{params: daily_coin_balance_entries},
       timeout: @timeout
     }
 
@@ -234,8 +255,12 @@ defmodule Indexer.Fetcher.TokenBalance do
 
   defp format_and_filter_address_params(token_balances_params) do
     token_balances_params
-    |> Enum.map(&%{hash: &1.address_hash})
-    |> Enum.uniq()
+    |> Enum.group_by(& &1.address_hash)
+    |> Map.values()
+    |> Stream.map(&Enum.max_by(&1, fn %{block_number: block_number} -> block_number end))
+    |> Enum.map(fn %{address_hash: address_hash, block_number: block_number, value: value} ->
+      %{hash: address_hash, fetched_coin_balance_block_number: block_number, fetched_coin_balance: value}
+    end)
   end
 
   defp format_and_filter_token_balance_params(token_balances_params) do

apps/indexer/lib/indexer/transform/xrpl-evm/coin_to_token_balance.ex

@@ -0,0 +1,27 @@
+defmodule Indexer.Transformers.CoinToTokenBalanceTransformer do
+  @doc """
+  Transforms changes to `address_coin_balances` into changes for `address_token_balances`
+  if the native token address is set.
+  """
+  def transform_address_coin_balances(params) do
+    native_token_address = System.get_env("NATIVE_TOKEN_ADDRESS")
+
+    Enum.flat_map(params, fn coin_balance ->
+      if native_token_address do
+        token_balance = %{
+          token_contract_address_hash: native_token_address,
+          address_hash: coin_balance[:address_hash],
+          block_number: coin_balance[:block_number],
+          value: coin_balance[:value],
+          token_type: "ERC-20",
+          token_id: 0,
+          value_fetched_at: coin_balance[:value_fetched_at]
+        }
+
+        [coin_balance, {:address_token_balance, token_balance}]
+      else
+        [coin_balance]
+      end
+    end)
+  end
+end

apps/indexer/lib/indexer/transform/xrpl-evm/token_to_coin_balance.ex

@@ -0,0 +1,24 @@
+defmodule Indexer.Transformers.TokenToCoinBalanceTransformer do
+  @doc """
+  Transforms changes to `address_token_balances` into changes for `address_coin_balances`
+  if the token contract address hash matches the hardcoded value.
+  """
+  def transform_address_token_balances(params) do
+    native_token_address = System.get_env("NATIVE_TOKEN_ADDRESS")
+
+    Enum.flat_map(params, fn token_balance ->
+      if token_balance[:token_contract_address_hash] == native_token_address do
+        coin_balance = %{
+          address_hash: token_balance[:address_hash],
+          value: token_balance[:value],
+          block_number: token_balance[:block_number],
+          value_fetched_at: token_balance[:value_fetched_at]
+        }
+
+        [token_balance, {:address_coin_balance, coin_balance}]
+      else
+        [token_balance]
+      end
+    end)
+  end
+end