feat: foreign key for agg mode proofs

Author: MarcosNicolau

explorer/lib/explorer/models/aggregated_proofs.ex

@@ -10,10 +10,11 @@ defmodule AggregatedProofs do
     field(:status, :integer)
     field(:tx_hash, :string)
     field(:blob_versioned_hash, :string)
-    field(:blob_data, :binary)
     field(:number_of_proofs, :integer)
     field(:block_number, :integer)
 
+    has_many(:proofs_agg_mode, AggregationModeProof)
+
     timestamps()
   end
 
@@ -29,23 +30,22 @@ defmodule AggregatedProofs do
       :blob_versioned_hash,
       :block_number,
       :tx_hash,
-      :blob_data,
       :number_of_proofs
     ])
     |> validate_required([
       :number,
-      :merkle_root,
       :status,
-      :tx_hash,
+      :merkle_root,
       :blob_versioned_hash,
-      :number_of_proofs,
-      :block_number
+      :block_number,
+      :tx_hash,
+      :number_of_proofs
     ])
     |> unique_constraint(:number)
   end
 
   def insert_or_update(agg_proof) do
-    changeset = AggregatedProofs.changeset(%AggregatedProofs{}, Map.from_struct(agg_proof))
+    changeset = AggregatedProofs.changeset(%AggregatedProofs{}, agg_proof)
 
     case Explorer.Repo.get_by(AggregatedProofs, number: agg_proof.number) do
       nil ->

explorer/lib/explorer/models/aggregation_mode_proof.ex

@@ -9,18 +9,39 @@ defmodule AggregationModeProof do
   schema "proofs_agg_mode" do
     field(:aggregated_proof_number, :integer)
     field(:proof_hash, :string)
+    field(:index, :integer)
+
+    belongs_to(:aggregated_proof, AggregatedProof,
+      define_field: false,
+      foreign_key: :aggregated_proof_number,
+      references: :number,
+      type: :integer
+    )
+
+    timestamps()
   end
 
   def changeset(proof, attrs) do
     proof
-    |> cast(attrs, [:aggregated_proof_number, :proof_hash])
-    |> validate_required([:aggregated_proof_number, :proof_hash])
+    |> cast(attrs, [:aggregated_proof_number, :proof_hash, :index])
+    |> validate_required([:aggregated_proof_number, :proof_hash, :index])
   end
 
-  def insert_proof(proof) do
+  def insert_or_update(proof) do
     changeset =
-      AggregationModeProof.changeset(%AggregationModeProof{}, Map.from_struct(proof))
+      AggregationModeProof.changeset(%AggregationModeProof{}, proof)
+
+    case(
+      Explorer.Repo.get_by(AggregationModeProof, proof_hash: proof.proof_hash, index: proof.index)
+    ) do
+      nil ->
+        Explorer.Repo.insert(changeset)
+
+      existing_proof ->
+        "Updating single aggregated proof" |> Logger.debug()
 
-    Explorer.Repo.insert(changeset)
+        Ecto.Changeset.change(existing_proof, changeset.changes)
+        |> Explorer.Repo.update()
+    end
   end
 end