feat: aggregation mode explorer

explorer/.env.dev

@@ -14,6 +14,9 @@ DB_HOST=localhost
 
 # Config file
 ALIGNED_CONFIG_FILE="../contracts/script/output/devnet/alignedlayer_deployment_output.json"
+ALIGNED_PROOF_AGG_CONFIG_FILE="../contracts/script/output/devnet/proof_aggregation_service_deployment_output.json"
+## Don't use public nodes as blob data can be retrieved from them
+BEACON_CLIENT="<beacon_client_url>"
 
 # Debug
 DEBUG_ERRORS=true

explorer/.env.example

@@ -14,6 +14,9 @@ DB_HOST=<db_host>
 
 # Config file
 ALIGNED_CONFIG_FILE="<aligned_config_file>"
+ALIGNED_PROOF_AGG_CONFIG_FILE="<proof_aggregation_config_file>"
+## Don't use public nodes as blob data can be retrieved from them
+BEACON_CLIENT="<beacon_client_url>"
 
 # Debug
 DEBUG_ERRORS=<true|false>

explorer/ecto_setup_db.sh

@@ -10,6 +10,8 @@ export DB_USER=$DB_USER
 export DB_PASS=$DB_PASS
 export DB_HOST=$DB_HOST
 export ALIGNED_CONFIG_FILE=$ALIGNED_CONFIG_FILE
+export ALIGNED_PROOF_AGG_CONFIG_FILE=$ALIGNED_PROOF_AGG_CONFIG_FILE
+export BEACON_CLIENT=$BEACON_CLIENT
 
 mix deps.get
 

explorer/lib/explorer/beacon_client.ex

@@ -0,0 +1,78 @@
+defmodule Explorer.BeaconClient do
+  require Logger
+  @beacon_url System.get_env("BEACON_CLIENT")
+  # See https://eips.ethereum.org/EIPS/eip-4844#parameters
+  @versioned_hash_version_kzg 0x01
+
+  def fetch_blob_by_versioned_hash!(slot, blob_versioned_hash) do
+    {:ok, blobs} = get_block_blobs(slot)
+    data = Map.get(blobs, "data")
+
+    Enum.find(data, fn blob ->
+      get_blob_versioned_hash(blob) == blob_versioned_hash
+    end)
+  end
+
+  def get_blob_versioned_hash(blob) do
+    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
+    raw = <<@versioned_hash_version_kzg::8>> <> rest
+    "0x" <> Base.encode16(raw, case: :lower)
+  end
+
+  def get_block_slot(beacon_block) do
+    String.to_integer(
+      beacon_block
+      |> Map.get("data")
+      |> Map.get("header")
+      |> Map.get("message")
+      |> Map.get("slot")
+    )
+  end
+
+  def get_block_header_by_hash(block_hash) do
+    beacon_get("/eth/v1/beacon/headers/#{block_hash}")
+  end
+
+  def get_block_header_by_parent_hash(parent_block_hash) do
+    case beacon_get("/eth/v1/beacon/headers?parent_root=#{parent_block_hash}") do
+      {:ok, header} ->
+        data = header["data"] |> Enum.at(0)
+
+        {:ok, %{header | "data" => data}}
+
+      other ->
+        other
+    end
+  end
+
+  def get_block_blobs(slot) do
+    beacon_get("/eth/v1/beacon/blob_sidecars/#{slot}")
+  end
+
+  defp beacon_get(method) do
+    headers = [{"Content-Type", "application/json"}]
+    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}
+        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

@@ -0,0 +1,136 @@
+defmodule AlignedProofAggregationService do
+  require Logger
+
+  @aligned_config_file System.get_env("ALIGNED_PROOF_AGG_CONFIG_FILE")
+
+  config_file_path =
+    case @aligned_config_file do
+      nil -> raise("ALIGNED_PROOF_AGG_CONFIG_FILE not set in .env")
+      file -> file
+    end
+
+  {status, config_json_string} = File.read(config_file_path)
+
+  case status do
+    :ok ->
+      Logger.debug("Aligned deployment file read successfully")
+
+    :error ->
+      raise(
+        "Config file not read successfully, make sure your .env is correctly created, and make sure Eigenlayer config file is correctly stored"
+      )
+  end
+
+  @contract_address Jason.decode!(config_json_string)
+                    |> Map.get("addresses")
+                    |> Map.get("alignedProofAggregationService")
+
+  use Ethers.Contract,
+    abi_file: "lib/abi/AlignedProofAggregationService.json",
+    default_address: @contract_address
+
+  def get_address() do
+    @contract_address
+  end
+
+  def get_aggregated_proof_event(%{from_block: fromBlock, to_block: toBlock}) do
+    events =
+      AlignedProofAggregationService.EventFilters.aggregated_proof_verified(nil)
+      |> Ethers.get_logs(fromBlock: fromBlock, toBlock: toBlock)
+
+    case events do
+      {:ok, []} ->
+        {:ok, []}
+
+      {:ok, list} ->
+        {: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)
+
+           %{
+             merkle_root:
+               topics_raw
+               |> Enum.at(1),
+             blob_versioned_hash: "0x" <> Base.encode16(data |> Enum.at(0), case: :lower),
+             block_number: block_number,
+             block_timestamp: get_block_timestamp(block_number),
+             tx_hash: tx_hash
+           }
+         end)}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def get_block_timestamp(block_number) do
+    case Ethers.Utils.get_block_timestamp(block_number) do
+      {:ok, timestamp} -> DateTime.from_unix!(timestamp)
+      {:error, error} -> raise("Error fetching block timestamp: #{error}")
+    end
+  end
+
+  def get_blob_data!(aggregated_proof) do
+    {:ok, block} =
+      Explorer.EthClient.get_block_by_number(
+        Explorer.Utils.decimal_to_hex(aggregated_proof.block_number)
+      )
+
+    parent_beacon_block_hash = Map.get(block, "parentBeaconBlockRoot")
+
+    {:ok, beacon_block} =
+      Explorer.BeaconClient.get_block_header_by_parent_hash(parent_beacon_block_hash)
+
+    slot = Explorer.BeaconClient.get_block_slot(beacon_block)
+
+    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 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
+        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)
+
+          false ->
+            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 limiter zeroed element
+              Enum.drop(acc, -1)
+            else
+              decode_blob(tail, acc ++ [[]], 0, total_count + 1, i + 1)
+            end
+        end
+    end
+  end
+end

explorer/lib/explorer/eth_client.ex

@@ -0,0 +1,30 @@
+defmodule Explorer.EthClient do
+  require Logger
+  @rpc_url System.get_env("RPC_URL")
+
+  def get_block_by_number(block_number) do
+    eth_send("eth_getBlockByNumber", [block_number, false])
+  end
+
+  defp eth_send(method, params, id \\ 1) do
+    headers = [{"Content-Type", "application/json"}]
+    body = Jason.encode!(%{jsonrpc: "2.0", method: method, params: params, id: id})
+    request = Finch.build(:post, @rpc_url, headers, body)
+    response = Finch.request(request, Explorer.Finch, [])
+
+    case response do
+      {:ok, %Finch.Response{status: 200, body: body}} ->
+        case Jason.decode(body) do
+          {:ok, %{error: error} = _} -> {:error, error.message}
+          {:ok, body} -> {:ok, Map.get(body, "result")}
+          {:error, _} -> {:error, :invalid_json}
+        end
+
+      {:ok, %Finch.Response{status: status}} ->
+        {:error, status}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+end

explorer/lib/explorer/models/aggregated_proofs.ex

@@ -0,0 +1,62 @@
+defmodule AggregatedProofs do
+  require Logger
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  schema "aggregated_proofs" do
+    field(:merkle_root, :string)
+    field(:blob_versioned_hash, :string)
+    field(:block_number, :integer)
+    field(:block_timestamp, :utc_datetime)
+    field(:tx_hash, :string)
+    field(:number_of_proofs, :integer)
+
+    has_many(:proofs_agg_mode, AggregationModeProof,
+      foreign_key: :agg_proof_id,
+      references: :id
+    )
+
+    timestamps()
+  end
+
+  @doc """
+  Creates a changeset based on the given `attrs`.
+  """
+  def changeset(aggregated_proof, attrs) do
+    aggregated_proof
+    |> cast(attrs, [
+      :id,
+      :merkle_root,
+      :blob_versioned_hash,
+      :block_number,
+      :block_timestamp,
+      :tx_hash,
+      :number_of_proofs
+    ])
+    |> validate_required([
+      :merkle_root,
+      :blob_versioned_hash,
+      :block_number,
+      :block_timestamp,
+      :tx_hash,
+      :number_of_proofs
+    ])
+    |> unique_constraint(:id)
+  end
+
+  def insert_or_update(agg_proof) do
+    changeset = AggregatedProofs.changeset(%AggregatedProofs{}, agg_proof)
+
+    case Explorer.Repo.get_by(AggregatedProofs, block_number: agg_proof.block_number) do
+      nil ->
+        Explorer.Repo.insert(changeset)
+
+      existing_agg_proof ->
+        "Updating aggregated proof" |> Logger.debug()
+
+        Ecto.Changeset.change(existing_agg_proof, changeset.changes)
+        |> Explorer.Repo.update()
+    end
+  end
+end

explorer/lib/explorer/models/aggregation_mode_proof.ex

@@ -0,0 +1,50 @@
+defmodule AggregationModeProof do
+  require Logger
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  # Different from proofs.ex (we could use the same but the hashes are constructed different)
+  @primary_key {:id, :id, autogenerate: true}
+  schema "proofs_agg_mode" do
+    field(:agg_proof_id, :binary_id)
+    field(:proof_hash, :string)
+    field(:index, :integer)
+
+    belongs_to(:aggregated_proof, AggregatedProof,
+      define_field: false,
+      foreign_key: :agg_proof_id,
+      references: :id,
+      type: :binary_id
+    )
+
+    timestamps()
+  end
+
+  def changeset(proof, attrs) do
+    proof
+    |> cast(attrs, [:agg_proof_id, :proof_hash, :index])
+    |> validate_required([:agg_proof_id, :proof_hash, :index])
+  end
+
+  def insert_or_update(proof) do
+    changeset =
+      AggregationModeProof.changeset(%AggregationModeProof{}, proof)
+
+    case(
+      Explorer.Repo.get_by(AggregationModeProof,
+        agg_proof_id: proof.agg_proof_id,
+        proof_hash: proof.proof_hash,
+        index: proof.index
+      )
+    ) do
+      nil ->
+        Explorer.Repo.insert(changeset)
+
+      existing_proof ->
+        "Updating single aggregated proof" |> Logger.debug()
+
+        Ecto.Changeset.change(existing_proof, changeset.changes)
+        |> Explorer.Repo.update()
+    end
+  end
+end