feat: fetch logs from contract

Author: MarcosNicolau

explorer/lib/abi/AlignedProofAggregationServiceDeployer.json

@@ -35,20 +35,36 @@ defmodule AlignedProofAggregationService do
 
   def get_aggregated_proof_event(%{from_block: number, to_block: number}) do
     events =
-      AlignedProofAggregationService.EventFilters.new_batch_v3(nil)
+      AlignedProofAggregationService.EventFilters.new_aggregated_proof(nil)
       |> Ethers.get_logs(fromBlock: fromBlock, toBlock: toBlock)
 
-    [
-      %{
-        number: 0,
-        status: 0,
-        merkle_root: "",
-        block_number: 0,
-        tx_hash: "",
-        tx_timestamp: "",
-        blob_versioned_hash: ""
-      }
-    ]
+    case events do
+      {: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)
+
+      {:error, reason} ->
+        raise("Error fetching events: #{Map.get(reason, "message")}")
+    end
   end
 
   def get_blob_data_from_versioned_hash(versioned_hash) do

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -4,7 +4,7 @@ defmodule AggregatedProofs do
   import Ecto.Changeset
   import Ecto.Query
 
-  # Different from proofs.ex (we could use the same but the hashes are constructed differently)
+  # Different from proofs.ex (we could use the same but the hashes are constructed different)
   @primary_key {:id, :integer, autogenerate: true}
   schema "proofs_agg_mode" do
     field(:aggregated_proof_number, :integer)
@@ -26,7 +26,6 @@ defmodule AggregatedProofs do
     field(:blob_data, :binary)
     field(:number_of_proofs, :integer)
     field(:block_number, :integer)
-    field(:tx_timestamp, :utc_datetime)
 
     timestamps()
   end
@@ -38,14 +37,13 @@ defmodule AggregatedProofs do
     aggregated_proof
     |> cast(attrs, [
       :number,
-      :merkle_root,
       :status,
-      :tx_hash,
+      :merkle_root,
       :blob_versioned_hash,
-      :blob_data,
-      :number_of_proofs,
       :block_number,
-      :tx_timestamp
+      :tx_hash,
+      :blob_data,
+      :number_of_proofs
     ])
     |> validate_required([
       :number,
@@ -54,8 +52,7 @@ defmodule AggregatedProofs do
       :tx_hash,
       :blob_versioned_hash,
       :number_of_proofs,
-      :block_number,
-      :tx_timestamp
+      :block_number
     ])
     |> unique_constraint(:number)
   end

explorer/lib/explorer/models/aggregated_proofs.ex

@@ -88,14 +88,17 @@ defmodule Explorer.Periodically do
     ## 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)
+    process_aggregated_proofs(read_from_block, latest_block_number)
   end
 
-  def process_aggregated_proofs(from_block) do
+  def process_aggregated_proofs(from_block, to_block) do
     "Processing aggregated proofs" |> Logger.debug()
 
     aggregated_proofs =
-      AlignedProofAggregationService.get_aggregated_proof_event()
+      AlignedProofAggregationService.get_aggregated_proof_event(%{
+        from_block: from_block,
+        to_block: to_block
+      })
       |> Enum.map(fn x ->
         Map.merge(
           x,