feat: beacon client to fetch blob data

Author: MarcosNicolau

explorer/lib/explorer/beacon_client.ex

@@ -0,0 +1,49 @@
+defmodule Explorer.BeaconClient do
+  @beacon_url System.get_env("BEACON_API_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
+      {:ok, blobs} ->
+        Enum.find(blobs, fn blob -> get_blob_versioned_hash(blob) == blob_versioned_hash end)
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def get_blob_versioned_hash(blob) do
+    hash = Explorer.Utils.sha256_hash_raw(blob.kzg_commitment)
+    # See https://eips.ethereum.org/EIPS/eip-4844#helpers
+    <<_first::8, rest::binary>> = hash
+    <<@versioned_hash_version_kzg::8>> <> rest
+  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
+  end
+
+  def beacon_get(method) do
+    headers = [{"Content-Type", "application/json"}]
+    request = Finch.build(:get, @beacon_url <> method, headers)
+    response = Finch.request(request, Explorer.Finch)
+
+    case status do
+      {:ok, %Finch.Response{status: 200, body: body}} ->
+        case Jason.decode(body) do
+          {:ok, decoded_body} -> {:ok, decoded_body}
+          {:error, _} -> {:error, :invalid_json}
+        end
+
+      {:ok, %Finch.Response{status: status}} ->
+        {:error, status}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+end

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -67,11 +67,13 @@ defmodule AlignedProofAggregationService do
     end
   end
 
-  def get_blob_data_from_versioned_hash(versioned_hash) do
-    # Fetch blob data from a beacon client
-    "Getting blob data from blob versioned hash: #{versioned_hash}" |> Logger.debug()
-    # List of bytes
-    blob_data = []
-    blob_data
+  def get_blob_data_from_versioned_hash(aggregated_proof) do
+    case BeaconClient.fetch_blob_by_versioned_hash(
+           aggregated_proof.block_number,
+           aggregated_proof.blob_versioned_hash
+         ) do
+      {:ok, data} -> data.blob
+      {:error, reason} -> {:error, reason}
+    end
   end
 end

explorer/lib/explorer/periodically.ex

@@ -80,14 +80,6 @@ defmodule Explorer.Periodically do
     latest_block_number = AlignedLayerServiceManager.get_latest_block_number()
     read_from_block = max(0, latest_block_number - read_block_qty)
 
-    ## What we need to do:
-    ## 1. Calculate the logs to fetch from block number
-    ## 2. Fetch the events: NewAggregatedProof
-    ## 3. For the successful verifications query the blob from a beacon client
-    ## 4. When getting the blob data, split in chunks of 32,
-    ## 5. Store each hash in proof hash pointing to the aggregated proof number
-    ## 6. Store the info in db
-
     process_aggregated_proofs(read_from_block, latest_block_number)
   end
 
@@ -103,17 +95,15 @@ defmodule Explorer.Periodically do
         Map.merge(
           x,
           %{
-            blob_data:
-              AlignedProofAggregationService.get_blob_data_from_versioned_hash(
-                x.blob_versioned_hash
-              )
+            blob_data: AlignedProofAggregationService.get_blob_data_from_versioned_hash(x)
           }
         )
       end)
 
     # Split the blob data in chunks of 32 to get the number of leaves (number of proofs) in the aggregated proof
+    ## TODO fix this parsing
     proofs_leaves =
-      Enum.map(aggregated_proofs, fn x -> chunk_every(x.blob_data, 2) end)
+      Enum.map(aggregated_proofs, fn x -> chunk_every(x.blob_data, 32) end)
 
     # Store aggregated proofs to db
     aggregated_proofs
@@ -127,13 +117,11 @@ defmodule Explorer.Periodically do
     aggregated_proofs
     |> Enum.zip(proofs_leaves)
     |> Enum.map(fn %{agg_proof, leaves} ->
-      Enum.map(leaves, fn leaf ->
-        %{
-          AggregatedProof.insert_proof(%{
-            aggregated_proof_number: agg_proof.number,
-            proof_hash: leaf
-          })
-        }
+      Enum.each(leaves, fn leaf ->
+        AggregatedProof.insert_proof(%{
+          aggregated_proof_number: agg_proof.number,
+          proof_hash: leaf
+        })
       end)
     end)
   end

explorer/lib/explorer/utils.ex

@@ -0,0 +1,11 @@
+defmodule Explorer.Utils do
+  def sha256_hash(data) do
+    ## Base 16 encoder needed as crypto.hash returns raw bytes
+    :crypto.hash(:sha256, data) |> Base.encode16(case: :lower)
+  end
+
+  ## Returns hash raw bytes
+  def sha256_hash_raw(data) do
+    :crypto.hash(:sha256, data)
+  end
+end

explorer/mix.exs

@@ -64,6 +64,7 @@ defmodule Explorer.MixProject do
       {:mutex, "~> 2.0"},
       {:tails, "~> 0.1.5"},
       {:cors_plug, "~> 3.0"},
+      {:crypto, "~> 1.11"}
     ]
   end