feat: blob decoding + parse events binaries

Author: MarcosNicolau

explorer/lib/explorer/beacon_client.ex

@@ -1,42 +1,65 @@
 defmodule Explorer.BeaconClient do
-  @beacon_url System.get_env("BEACON_API_URL")
+  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(block_number, blob_versioned_hash) do
-    case get_block_blobs(block_number) do
+  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)
+
+    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} ->
-        Enum.find(blobs, fn blob -> get_blob_versioned_hash(blob) == blob_versioned_hash end)
+        data = Map.get(blobs, "data")
+
+        blob =
+          Enum.find(data, fn blob ->
+            get_blob_versioned_hash(blob) == blob_versioned_hash
+          end)
+
+        {:ok, blob}
 
       {:error, reason} ->
         {:error, reason}
     end
   end
 
   def get_blob_versioned_hash(blob) do
-    hash = Explorer.Utils.sha256_hash_raw(blob.kzg_commitment)
+    kzg_commitment = String.replace(Map.get(blob, "kzg_commitment"), "0x", "")
+    kzg_commitment = Base.decode16!(kzg_commitment, case: :mixed)
+    hash = Explorer.Utils.sha256_hash_raw(kzg_commitment)
     # See https://eips.ethereum.org/EIPS/eip-4844#helpers
     <<_first::8, rest::binary>> = hash
-    <<@versioned_hash_version_kzg::8>> <> rest
+    raw = <<@versioned_hash_version_kzg::8>> <> rest
+    "0x" <> Base.encode16(raw, case: :lower)
   end
 
-  def get_block_blobs(block_number) do
-    case beacon_get("/eth/v1/beacon/blob_sidecars/" <> block_number) do
-      {:ok, res} -> res.data
-      {:error, reason} -> {:error, reason}
-    end
+  def get_block_blobs(slot) do
+    beacon_get("/eth/v1/beacon/blob_sidecars/#{slot}")
+  end
+
+  def get_beacon_block_header_by_hash(block_hash) do
+    beacon_get("/eth/v1/beacon/headers/#{block_hash}")
   end
 
   def beacon_get(method) do
     headers = [{"Content-Type", "application/json"}]
-    request = Finch.build(:get, @beacon_url <> method, headers)
+    request = Finch.build(:get, "#{@beacon_url}#{method}", headers)
     response = Finch.request(request, Explorer.Finch)
 
     case response do
       {:ok, %Finch.Response{status: 200, body: body}} ->
         case Jason.decode(body) do
-          {:ok, decoded_body} -> {:ok, decoded_body}
-          {:error, _} -> {:error, :invalid_json}
+          {:ok, decoded_body} ->
+            {:ok, decoded_body}
+
+          {:error, _} ->
+            {:error, :invalid_json}
         end
 
       {:ok, %Finch.Response{status: status}} ->

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -40,40 +40,84 @@ defmodule AlignedProofAggregationService do
 
     case events do
       {:ok, []} ->
-        []
+        {:ok, []}
 
       {:ok, list} ->
-        Enum.map(list, fn x ->
-          data = x |> Map.get(:data)
-          topics_raw = x |> Map.get(:topics_raw)
-          block_number = x |> Map.get(:block_number)
-          tx_hash = x |> Map.get(:transaction_hash)
-
-          {
-            :ok,
-            %{
-              number: topics_raw |> Enum.at(1),
-              status: data |> Enum.at(0),
-              merkle_root: data |> Enum.at(1),
-              blob_versioned_hash: data |> Enum.at(2),
-              block_number: block_number,
-              tx_hash: tx_hash
-            }
-          }
-        end)
+        {:ok,
+         Enum.map(list, fn x ->
+           data = x |> Map.get(:data)
+           topics_raw = x |> Map.get(:topics_raw)
+           block_number = x |> Map.get(:block_number)
+           tx_hash = x |> Map.get(:transaction_hash)
+
+           %{
+             number:
+               topics_raw
+               |> Enum.at(1)
+               |> String.replace_prefix("0x", "")
+               |> String.to_integer(16),
+             status: data |> Enum.at(0),
+             merkle_root: "0x" <> Base.encode16(data |> Enum.at(1), case: :lower),
+             blob_versioned_hash: "0x" <> Base.encode16(data |> Enum.at(2), case: :lower),
+             block_number: block_number,
+             tx_hash: tx_hash
+           }
+         end)}
 
       {:error, reason} ->
         raise("Error fetching events: #{Map.get(reason, "message")}")
     end
   end
 
   def get_blob_data_from_versioned_hash(aggregated_proof) do
-    case BeaconClient.fetch_blob_by_versioned_hash(
-           aggregated_proof.block_number,
+    {: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} -> data.blob
+      {:ok, data} -> {:ok, Map.get(data, "blob")}
       {:error, reason} -> {:error, reason}
     end
   end
+
+  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
+    should_skip = rem(total_count, 64) == 0
+
+    case should_skip do
+      true ->
+        [head | tail] = tail
+        decode_blob(tail, acc, current_count, total_count + 2, i)
+
+      false ->
+        acc = List.update_at(acc, i, fn chunk -> chunk ++ [head] end)
+
+        case current_count + 1 < 64 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)
+            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
+              Enum.drop(acc, -1)
+            else
+              decode_blob(tail, acc ++ [[]], 0, total_count + 1, i + 1)
+            end
+        end
+    end
+  end
 end

explorer/lib/explorer/utils.ex

@@ -8,4 +8,8 @@ defmodule Explorer.Utils do
   def sha256_hash_raw(data) do
     :crypto.hash(:sha256, data)
   end
+
+  def decimal_to_hex(number) do
+    "0x#{Integer.to_string(number, 16)}"
+  end
 end