feat: update models to new contract version

Author: MarcosNicolau

explorer/lib/abi/AlignedProofAggregationService.json

@@ -35,7 +35,7 @@ defmodule AlignedProofAggregationService do
 
   def get_aggregated_proof_event(%{from_block: fromBlock, to_block: toBlock}) do
     events =
-      AlignedProofAggregationService.EventFilters.new_aggregated_proof(nil)
+      AlignedProofAggregationService.EventFilters.aggregated_proof_verified(nil)
       |> Ethers.get_logs(fromBlock: fromBlock, toBlock: toBlock)
 
     case events do
@@ -51,14 +51,10 @@ defmodule AlignedProofAggregationService do
            tx_hash = x |> Map.get(:transaction_hash)
 
            %{
-             number:
+             merkle_root:
                topics_raw
-               |> Enum.at(1)
-               |> String.replace_prefix("0x", "")
-               |> String.to_integer(16),
-             status: data |> Enum.at(0),
-             merkle_root: "0x" <> Base.encode16(data |> Enum.at(1), case: :lower),
-             blob_versioned_hash: "0x" <> Base.encode16(data |> Enum.at(2), case: :lower),
+               |> Enum.at(1),
+             blob_versioned_hash: "0x" <> Base.encode16(data |> Enum.at(0), case: :lower),
              block_number: block_number,
              tx_hash: tx_hash
            }

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -3,18 +3,16 @@ defmodule AggregatedProofs do
   use Ecto.Schema
   import Ecto.Changeset
 
-  @primary_key {:number, :integer, autogenerate: false}
+  @primary_key {:merkle_root, :string, autogenerate: false}
   schema "aggregated_proofs" do
-    field(:merkle_root, :string)
-    field(:status, :integer)
-    field(:tx_hash, :string)
     field(:blob_versioned_hash, :string)
-    field(:number_of_proofs, :integer)
     field(:block_number, :integer)
+    field(:tx_hash, :string)
+    field(:number_of_proofs, :integer)
 
     has_many(:proofs_agg_mode, AggregationModeProof,
-      foreign_key: :aggregated_proof_number,
-      references: :number
+      foreign_key: :merkle_root,
+      references: :merkle_root
     )
 
     timestamps()
@@ -26,30 +24,26 @@ defmodule AggregatedProofs do
   def changeset(aggregated_proof, attrs) do
     aggregated_proof
     |> cast(attrs, [
-      :number,
-      :status,
       :merkle_root,
       :blob_versioned_hash,
       :block_number,
       :tx_hash,
       :number_of_proofs
     ])
     |> validate_required([
-      :number,
-      :status,
       :merkle_root,
       :blob_versioned_hash,
       :block_number,
       :tx_hash,
       :number_of_proofs
     ])
-    |> unique_constraint(:number)
+    |> unique_constraint(:merkle_root)
   end
 
   def insert_or_update(agg_proof) do
     changeset = AggregatedProofs.changeset(%AggregatedProofs{}, agg_proof)
 
-    case Explorer.Repo.get_by(AggregatedProofs, number: agg_proof.number) do
+    case Explorer.Repo.get_by(AggregatedProofs, merkle_root: agg_proof.merkle_root) do
       nil ->
         Explorer.Repo.insert(changeset)
 

explorer/lib/explorer/models/aggregated_proofs.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(:aggregated_proof_number, :integer)
+    field(:merkle_root, :string)
     field(:proof_hash, :string)
     field(:index, :integer)
 
     belongs_to(:aggregated_proof, AggregatedProof,
       define_field: false,
-      foreign_key: :aggregated_proof_number,
-      references: :number,
-      type: :integer
+      foreign_key: :merkle_root,
+      references: :merkle_root,
+      type: :string
     )
 
     timestamps()
   end
 
   def changeset(proof, attrs) do
     proof
-    |> cast(attrs, [:aggregated_proof_number, :proof_hash, :index])
-    |> validate_required([:aggregated_proof_number, :proof_hash, :index])
+    |> cast(attrs, [:merkle_root, :proof_hash, :index])
+    |> validate_required([:merkle_root, :proof_hash, :index])
   end
 
   def insert_or_update(proof) do

explorer/lib/explorer/models/aggregation_mode_proof.ex

@@ -121,7 +121,7 @@ defmodule Explorer.Periodically do
       |> Enum.with_index()
       |> Enum.each(fn {hash, index} ->
         AggregationModeProof.insert_or_update(%{
-          aggregated_proof_number: agg_proof.number,
+          merkle_root: agg_proof.merkle_root,
           proof_hash: "0x" <> List.to_string(hash),
           index: index
         })

explorer/lib/explorer/periodically.ex

@@ -3,9 +3,7 @@ defmodule Explorer.Repo.Migrations.CreateAggregatedProofs do
 
   def change do
     create table(:aggregated_proofs, primary_key: false) do
-      add(:number, :integer, primary_key: true)
-      add(:merkle_root, :string)
-      add(:status, :integer)
+      add(:merkle_root, :string, primary_key: true)
       add(:tx_hash, :string)
       add(:blob_versioned_hash, :string)
       add(:number_of_proofs, :integer)
@@ -16,16 +14,18 @@ defmodule Explorer.Repo.Migrations.CreateAggregatedProofs do
 
     create table(:proofs_agg_mode) do
       add(
-        :aggregated_proof_number,
-        references(:aggregated_proofs, column: :number, type: :integer, on_delete: :delete_all)
+        :merkle_root,
+        references(:aggregated_proofs,
+          column: :merkle_root,
+          type: :string,
+          on_delete: :delete_all
+        )
       )
 
       add(:proof_hash, :string)
       add(:index, :integer)
 
       timestamps()
     end
-
-    create(index(:proofs_agg_mode, [:aggregated_proof_number]))
   end
 end