refactor: more idiomatic elixir and made panics explicit

Author: MarcosNicolau

explorer/lib/explorer/beacon_client.ex

@@ -1,32 +1,28 @@
 defmodule Explorer.BeaconClient do
   require Logger
   @beacon_url System.get_env("BEACON_CLIENT")
-  @rpc_url System.get_env("RPC_URL")
   # See https://eips.ethereum.org/EIPS/eip-4844#parameters
   @versioned_hash_version_kzg 0x01
 
-  def fetch_blob_by_versioned_hash(beacon_blob_hash, blob_versioned_hash) do
-    {:ok, beacon_block} = get_beacon_block_header_by_hash(beacon_blob_hash)
+  def get_block_slot!(block_hash) do
+    {:ok, beacon_block} = get_beacon_block_header_by_hash(block_hash)
 
-    slot =
-      String.to_integer(
-        Map.get(Map.get(Map.get(Map.get(beacon_block, "data"), "header"), "message"), "slot")
-      )
-
-    case get_block_blobs(slot + 1) do
-      {:ok, blobs} ->
-        data = Map.get(blobs, "data")
-
-        blob =
-          Enum.find(data, fn blob ->
-            get_blob_versioned_hash(blob) == blob_versioned_hash
-          end)
+    String.to_integer(
+      beacon_block
+      |> Map.get("data")
+      |> Map.get("header")
+      |> Map.get("message")
+      |> Map.get("slot")
+    )
+  end
 
-        {:ok, blob}
+  def fetch_blob_by_versioned_hash!(slot, blob_versioned_hash) do
+    {:ok, blobs} = get_block_blobs(slot)
+    data = Map.get(blobs, "data")
 
-      {:error, reason} ->
-        {:error, reason}
-    end
+    Enum.find(data, fn blob ->
+      get_blob_versioned_hash(blob) == blob_versioned_hash
+    end)
   end
 
   def get_blob_versioned_hash(blob) do

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -65,36 +65,42 @@ defmodule AlignedProofAggregationService do
          end)}
 
       {:error, reason} ->
-        raise("Error fetching events: #{Map.get(reason, "message")}")
+        {:error, reason}
     end
   end
 
-  def get_blob_data_from_versioned_hash(aggregated_proof) do
+  def get_blob_data!(aggregated_proof) do
     {:ok, block} =
       Explorer.EthClient.get_block_by_number(
         Explorer.Utils.decimal_to_hex(aggregated_proof.block_number)
       )
 
-    case Explorer.BeaconClient.fetch_blob_by_versioned_hash(
-           Map.get(block, "parentBeaconBlockRoot"),
-           aggregated_proof.blob_versioned_hash
-         ) do
-      {:ok, data} -> {:ok, Map.get(data, "blob")}
-      {:error, reason} -> {:error, reason}
-    end
+    parent_beacon_block_hash = Map.get(block, "parentBeaconBlockRoot")
+    slot = Explorer.BeaconClient.get_block_slot!(parent_beacon_block_hash) + 1
+
+    data =
+      Explorer.BeaconClient.fetch_blob_by_versioned_hash!(
+        slot,
+        aggregated_proof.blob_versioned_hash
+      )
+
+    Map.get(data, "blob")
   end
 
+  @doc """
+  Decodes blob data represented as an ASCII charlist.
+  """
   def decode_blob(blob_data), do: decode_blob(blob_data, [[]], 0, 0, 0)
 
   defp decode_blob([], acc, _current_count, _total_count, _i), do: acc
 
   defp decode_blob([head | tail], acc, current_count, total_count, i) do
-    # Every 32 bytes there is a 00 for padding
+    # Every 64 characters (or 32 bytes) there is a 00 for padding
     should_skip = rem(total_count, 64) == 0
 
     case should_skip do
       true ->
-        [head | tail] = tail
+        [_head | tail] = tail
         decode_blob(tail, acc, current_count, total_count + 2, i)
 
       false ->
@@ -104,15 +110,14 @@ defmodule AlignedProofAggregationService do
           true ->
             decode_blob(tail, acc, current_count + 1, total_count + 1, i)
 
-          # New hash encountered, this would be the index 0, so next iteration go to 1
           false ->
-            # The iteration finishes when the acc is 0x00
             current_blob = Enum.at(acc, i)
+            # 48 is 0 in ascii
             is_all_zeroes = Enum.all?(current_blob, fn x -> x == 48 end)
 
             ## If the hash is all zeroed, then there are no more hashes in the blob
             if is_all_zeroes do
-              # Drop last element as it is made all out of zeroes and it is the one we use to stop decoding
+              # Drop last limiter zeroed element
               Enum.drop(acc, -1)
             else
               decode_blob(tail, acc ++ [[]], 0, total_count + 1, i + 1)

explorer/lib/explorer/periodically.ex

@@ -74,42 +74,29 @@ defmodule Explorer.Periodically do
   end
 
   def handle_info(:aggregated_proofs, state) do
-    # This runs every 1hr, so reading 300 means going back exactly one hour
-    # We add a few blocks more to make sure we don't lose anything
     read_block_qty = 310
     latest_block_number = AlignedLayerServiceManager.get_latest_block_number()
     read_from_block = max(0, latest_block_number - read_block_qty)
 
-    process_aggregated_proofs(read_from_block, latest_block_number)
+    Task.start(fn -> process_aggregated_proofs(read_from_block, latest_block_number) end)
 
     {:noreply, state}
   end
 
   def process_aggregated_proofs(from_block, to_block) do
     "Processing aggregated proofs" |> Logger.debug()
 
-    events =
+    {:ok, proofs} =
       AlignedProofAggregationService.get_aggregated_proof_event(%{
         from_block: from_block,
         to_block: to_block
       })
 
-    proofs =
-      case events do
-        {:ok, events} -> events
-        {:error, reason} -> raise(reason)
-      end
-
     blob_data =
       proofs
-      |> Enum.map(fn x ->
-        case AlignedProofAggregationService.get_blob_data_from_versioned_hash(x) do
-          {:ok, data} -> data
-          {:error, reason} -> raise("Error #{reason}")
-        end
-      end)
+      |> Enum.map(&AlignedProofAggregationService.get_blob_data!/1)
 
-    proofs_leaves =
+    proof_hashes =
       blob_data
       |> Enum.map(fn x ->
         AlignedProofAggregationService.decode_blob(
@@ -119,23 +106,23 @@ defmodule Explorer.Periodically do
 
     # Store aggregated proofs to db
     proofs
-    |> Enum.zip(proofs_leaves)
-    |> Enum.each(fn {agg_proof, leaves} ->
+    |> Enum.zip(proof_hashes)
+    |> Enum.each(fn {agg_proof, hashes} ->
       agg_proof
-      |> Map.merge(%{number_of_proofs: length(leaves)})
+      |> Map.merge(%{number_of_proofs: length(hashes)})
       |> AggregatedProofs.insert_or_update()
     end)
 
     # Store each individual proof
     proofs
-    |> Enum.zip(proofs_leaves)
-    |> Enum.each(fn {agg_proof, leaves} ->
-      leaves
+    |> Enum.zip(proof_hashes)
+    |> Enum.each(fn {agg_proof, hashes} ->
+      hashes
       |> Enum.with_index()
-      |> Enum.each(fn {leaf, index} ->
+      |> Enum.each(fn {hash, index} ->
         AggregationModeProof.insert_or_update(%{
           aggregated_proof_number: agg_proof.number,
-          proof_hash: "0x" <> List.to_string(leaf),
+          proof_hash: "0x" <> List.to_string(hash),
           index: index
         })
       end)