fix: compilation warnings

Author: MarcosNicolau

explorer/lib/abi/AlignedProofAggregationService.json

@@ -32,7 +32,7 @@ defmodule Explorer.BeaconClient do
     request = Finch.build(:get, @beacon_url <> method, headers)
     response = Finch.request(request, Explorer.Finch)
 
-    case status do
+    case response do
       {:ok, %Finch.Response{status: 200, body: body}} ->
         case Jason.decode(body) do
           {:ok, decoded_body} -> {:ok, decoded_body}

explorer/lib/abi/AlignedProofAggregationServiceDeployer.json

@@ -33,7 +33,7 @@ defmodule AlignedProofAggregationService do
     @contract_address
   end
 
-  def get_aggregated_proof_event(%{from_block: number, to_block: number}) do
+  def get_aggregated_proof_event(%{from_block: fromBlock, to_block: toBlock}) do
     events =
       AlignedProofAggregationService.EventFilters.new_aggregated_proof(nil)
       |> Ethers.get_logs(fromBlock: fromBlock, toBlock: toBlock)
@@ -49,7 +49,7 @@ defmodule AlignedProofAggregationService do
           block_number = x |> Map.get(:block_number)
           tx_hash = x |> Map.get(:transaction_hash)
 
-          %{
+          {
             :ok,
             %{
               number: topics_raw |> Enum.at(1),

explorer/lib/explorer/beacon_client.ex

@@ -4,19 +4,6 @@ defmodule AggregatedProofs do
   import Ecto.Changeset
   import Ecto.Query
 
-  # 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)
-    field(:proof_hash, :string)
-  end
-
-  def changeset_proof(proof, attrs) do
-    proofs
-    |> cast(attrs, [:aggregated_proof_number, :proof_hash])
-    |> validate_required([:aggregated_proof_number, :proof_hash])
-  end
-
   @primary_key {:number, :integer, autogenerate: false}
   schema "aggregated_proofs" do
     field(:merkle_root, :string)
@@ -71,9 +58,4 @@ defmodule AggregatedProofs do
         |> Explorer.Repo.update()
     end
   end
-
-  def insert_proof(proof) do
-    changeset = changeset_proof(proof)
-    Explorer.Repo.insert(changeset)
-  end
 end

explorer/lib/explorer/contract_managers/aligned_proof_aggregation_service.ex

@@ -0,0 +1,26 @@
+defmodule AggregationModeProof do
+  require Logger
+  use Ecto.Schema
+  import Ecto.Changeset
+  import Ecto.Query
+
+  # 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(:proof_hash, :string)
+  end
+
+  def changeset(proof, attrs) do
+    proof
+    |> cast(attrs, [:aggregated_proof_number, :proof_hash])
+    |> validate_required([:aggregated_proof_number, :proof_hash])
+  end
+
+  def insert_proof(proof) do
+    changeset =
+      AggregationModeProof.changeset(%AggregationModeProof{}, Map.from_struct(proof))
+
+    Explorer.Repo.insert(changeset)
+  end
+end

explorer/lib/explorer/models/aggregated_proofs.ex

@@ -103,22 +103,22 @@ defmodule Explorer.Periodically do
     # Split the blob data in chunks of 32 to get the number of leaves (number of proofs) in the aggregated proof
     ## TODO fix this parsing
     proofs_leaves =
-      Enum.map(aggregated_proofs, fn x -> chunk_every(x.blob_data, 32) end)
+      Enum.map(aggregated_proofs, fn x -> Enum.chunk_every(x.blob_data, 32) end)
 
     # Store aggregated proofs to db
     aggregated_proofs
     |> Enum.zip(proofs_leaves)
-    |> Enum.map(fn %{agg_proof, leaves} ->
+    |> Enum.map(fn {agg_proof, leaves} ->
       Map.merge(agg_proof, %{number_of_proofs: length(leaves)})
       |> Enum.each(fn x -> AggregatedProof.insert_or_update(x) end)
     end)
 
     # Store each individual proof
     aggregated_proofs
     |> Enum.zip(proofs_leaves)
-    |> Enum.map(fn %{agg_proof, leaves} ->
+    |> Enum.map(fn {agg_proof, leaves} ->
       Enum.each(leaves, fn leaf ->
-        AggregatedProof.insert_proof(%{
+        AggregationModeProof.insert_proof(%{
           aggregated_proof_number: agg_proof.number,
           proof_hash: leaf
         })