feat: agg_proofs relation by uuid instead of merkle root

Author: MarcosNicolau

explorer/lib/explorer/models/aggregated_proofs.ex

@@ -3,17 +3,18 @@ defmodule AggregatedProofs do
   use Ecto.Schema
   import Ecto.Changeset
 
-  @primary_key {:merkle_root, :string, autogenerate: false}
+  @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: :merkle_root,
-      references: :merkle_root
+      foreign_key: :agg_proof_id,
+      references: :id
     )
 
     timestamps()
@@ -25,6 +26,7 @@ defmodule AggregatedProofs do
   def changeset(aggregated_proof, attrs) do
     aggregated_proof
     |> cast(attrs, [
+      :id,
       :merkle_root,
       :blob_versioned_hash,
       :block_number,
@@ -40,13 +42,13 @@ defmodule AggregatedProofs do
       :tx_hash,
       :number_of_proofs
     ])
-    |> unique_constraint(:merkle_root)
+    |> unique_constraint(:id)
   end
 
   def insert_or_update(agg_proof) do
     changeset = AggregatedProofs.changeset(%AggregatedProofs{}, agg_proof)
 
-    case Explorer.Repo.get_by(AggregatedProofs, merkle_root: agg_proof.merkle_root) do
+    case Explorer.Repo.get_by(AggregatedProofs, block_number: agg_proof.block_number) do
       nil ->
         Explorer.Repo.insert(changeset)
 

explorer/lib/explorer/models/aggregation_mode_proof.ex

@@ -6,24 +6,24 @@ defmodule AggregationModeProof do
   # 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(:merkle_root, :string)
+    field(:agg_proof_id, :binary_id)
     field(:proof_hash, :string)
     field(:index, :integer)
 
     belongs_to(:aggregated_proof, AggregatedProof,
       define_field: false,
-      foreign_key: :merkle_root,
-      references: :merkle_root,
-      type: :string
+      foreign_key: :agg_proof_id,
+      references: :id,
+      type: :binary_id
     )
 
     timestamps()
   end
 
   def changeset(proof, attrs) do
     proof
-    |> cast(attrs, [:merkle_root, :proof_hash, :index])
-    |> validate_required([:merkle_root, :proof_hash, :index])
+    |> cast(attrs, [:agg_proof_id, :proof_hash, :index])
+    |> validate_required([:agg_proof_id, :proof_hash, :index])
   end
 
   def insert_or_update(proof) do

explorer/lib/explorer/periodically.ex

@@ -22,7 +22,7 @@ defmodule Explorer.Periodically do
     :timer.send_interval(one_second * 12, :batches)
     # every 1 hour
     :timer.send_interval(one_second * seconds_in_an_hour, :restakings)
-    :timer.send_interval(one_second * seconds_in_an_hour, :aggregated_proofs)
+    :timer.send_interval(one_second * 12, :aggregated_proofs)
   end
 
   # Reads and process last blocks for operators and restaking changes
@@ -74,7 +74,7 @@ defmodule Explorer.Periodically do
   end
 
   def handle_info(:aggregated_proofs, state) do
-    read_block_qty = 310
+    read_block_qty = 50000
     latest_block_number = AlignedLayerServiceManager.get_latest_block_number()
     read_from_block = max(0, latest_block_number - read_block_qty)
 
@@ -105,13 +105,18 @@ defmodule Explorer.Periodically do
       end)
 
     # Store aggregated proofs to db
-    proofs
-    |> Enum.zip(proof_hashes)
-    |> Enum.each(fn {agg_proof, hashes} ->
-      agg_proof
-      |> Map.merge(%{number_of_proofs: length(hashes)})
-      |> AggregatedProofs.insert_or_update()
-    end)
+    proofs =
+      proofs
+      |> Enum.zip(proof_hashes)
+      |> Enum.map(fn {agg_proof, hashes} ->
+        agg_proof =
+          agg_proof
+          |> Map.merge(%{number_of_proofs: length(hashes)})
+
+        {:ok, %{id: id}} = AggregatedProofs.insert_or_update(agg_proof)
+
+        Map.merge(agg_proof, %{id: id})
+      end)
 
     # Store each individual proof
     proofs
@@ -121,7 +126,7 @@ defmodule Explorer.Periodically do
       |> Enum.with_index()
       |> Enum.each(fn {hash, index} ->
         AggregationModeProof.insert_or_update(%{
-          merkle_root: agg_proof.merkle_root,
+          agg_proof_id: agg_proof.id,
           proof_hash: "0x" <> List.to_string(hash),
           index: index
         })

explorer/priv/repo/migrations/20250407002009_create_aggregated_proofs.exs

@@ -3,7 +3,8 @@ defmodule Explorer.Repo.Migrations.CreateAggregatedProofs do
 
   def change do
     create table(:aggregated_proofs, primary_key: false) do
-      add(:merkle_root, :string, primary_key: true)
+      add(:id, :binary_id, primary_key: true)
+      add(:merkle_root, :string)
       add(:tx_hash, :string)
       add(:blob_versioned_hash, :string)
       add(:number_of_proofs, :integer)
@@ -15,10 +16,10 @@ defmodule Explorer.Repo.Migrations.CreateAggregatedProofs do
 
     create table(:proofs_agg_mode) do
       add(
-        :merkle_root,
+        :agg_proof_id,
         references(:aggregated_proofs,
-          column: :merkle_root,
-          type: :string,
+          column: :id,
+          type: :binary_id,
           on_delete: :delete_all
         )
       )