feat(explorer): add cost per proof of batch (#617)

Co-authored-by: Urix <43704209+uri-99@users.noreply.github.com>

Author: glpecile

explorer/lib/explorer/aligned_layer_service_manager.ex

@@ -12,30 +12,52 @@ defmodule AlignedLayerServiceManager do
     nil -> raise("Invalid ENVIRONMENT var in .env")
   end
 
-  config_file_path = case @aligned_config_file do
-    nil -> raise("ALIGNED_CONFIG_FILE not set in .env")
-    file -> file
+  config_file_path =
+    case @aligned_config_file do
+      nil -> raise("ALIGNED_CONFIG_FILE not set in .env")
+      file -> file
+    end
+
+  payment_service_path =
+    "../contracts/script/deploy/config/#{@environment}/batcher-payment-service.#{@environment}.config.json"
+
+  {status_aligned_config, config_json_string} = File.read(config_file_path)
+  {status_payment_service, payment_service_json_string} = File.read(payment_service_path)
+
+  case status_aligned_config do
+    :ok ->
+      Logger.debug("Aligned config file read successfully")
+
+    :error ->
+      raise(
+        "Config file not read successfully, did you run make create-env? If you did,\n make sure Alignedlayer config file is correctly stored"
+      )
   end
 
-  {status, config_json_string} = File.read(config_file_path)
+  case status_payment_service do
+    :ok ->
+      Logger.debug("Payment service file read successfully")
 
-  case status do
-    :ok -> Logger.debug("File read successfully")
-    :error -> raise("Config file not read successfully, did you run make create-env? If you did,\n make sure Alignedlayer config file is correctly stored")
+    :error ->
+      raise(
+        "Payment service file not read successfully, did you run make create-env? If you did,\n make sure Alignedlayer config file is correctly stored"
+      )
   end
 
   @aligned_layer_service_manager_address Jason.decode!(config_json_string)
                                          |> Map.get("addresses")
                                          |> Map.get("alignedLayerServiceManager")
 
-  @first_block (
-    case @environment do
-      "devnet" -> 0
-      "holesky" -> 1728056
-      "mainnet" -> 20020000
-      _ -> raise("Invalid environment")
-    end
-  )
+  @gas_per_proof Jason.decode!(payment_service_json_string)
+                 |> Map.get("amounts")
+                 |> Map.get("gasPerProof")
+
+  @first_block (case @environment do
+                  "devnet" -> 0
+                  "holesky" -> 1_728_056
+                  "mainnet" -> 20_020_000
+                  _ -> raise("Invalid environment")
+                end)
 
   use Ethers.Contract,
     abi_file: "lib/abi/AlignedLayerServiceManager.json",
@@ -58,12 +80,13 @@ defmodule AlignedLayerServiceManager do
     case events do
       {:ok, []} -> []
       {:ok, list} -> Enum.map(list, &extract_new_batch_event_info/1)
-      {:error, reason } -> raise("Error fetching events: #{Map.get(reason, "message")}")
+      {:error, reason} -> raise("Error fetching events: #{Map.get(reason, "message")}")
     end
   end
 
   def extract_new_batch_event_info(event) do
     new_batch = parse_new_batch_event(event)
+
     {:ok,
      %NewBatchInfo{
        address: event |> Map.get(:address),
@@ -97,10 +120,14 @@ defmodule AlignedLayerServiceManager do
   def extract_batch_response({_status, %NewBatchInfo{} = batch_creation}) do
     created_batch = batch_creation.new_batch
     was_batch_responded = is_batch_responded(created_batch.batchMerkleRoot)
-    batch_response = case was_batch_responded do
-      true -> fetch_batch_response(created_batch.batchMerkleRoot)
-      false -> %{block_number: nil, transaction_hash: nil, block_timestamp: nil} #was not verified, fill with nils
-    end
+
+    batch_response =
+      case was_batch_responded do
+        true -> fetch_batch_response(created_batch.batchMerkleRoot)
+        # was not verified, fill with nils
+        false -> %{block_number: nil, transaction_hash: nil, block_timestamp: nil}
+      end
+
     %BatchDB{
       merkle_root: created_batch.batchMerkleRoot,
       data_pointer: created_batch.batchDataPointer,
@@ -112,17 +139,23 @@ defmodule AlignedLayerServiceManager do
       response_transaction_hash: batch_response.transaction_hash,
       response_timestamp: batch_response.block_timestamp,
       amount_of_proofs: nil,
-      proof_hashes: nil
+      proof_hashes: nil,
+      cost_per_proof: get_cost_per_proof()
     }
   end
 
-  #for existing but unverified batches
+  # for existing but unverified batches
   def extract_batch_response(%Batches{} = unverified_batch) do
     was_batch_responded = is_batch_responded(unverified_batch.merkle_root)
+
     case was_batch_responded do
-      false -> nil # Do nothing since unverified batch was not yet verified
+      # Do nothing since unverified batch was not yet verified
+      false ->
+        nil
+
       true ->
         batch_response = fetch_batch_response(unverified_batch.merkle_root)
+
         %BatchDB{
           merkle_root: unverified_batch.merkle_root,
           data_pointer: unverified_batch.data_pointer,
@@ -134,6 +167,7 @@ defmodule AlignedLayerServiceManager do
           response_transaction_hash: batch_response.transaction_hash,
           response_timestamp: batch_response.block_timestamp,
           amount_of_proofs: unverified_batch.amount_of_proofs,
+          cost_per_proof: unverified_batch.cost_per_proof,
           proof_hashes: nil #don't need this value to update an existing but unverified batch, it is on another table
         }
     end
@@ -150,7 +184,7 @@ defmodule AlignedLayerServiceManager do
   def get_batch_verified_events(%{merkle_root: merkle_root}) do
     event =
       AlignedLayerServiceManager.EventFilters.batch_verified(Utils.string_to_bytes32(merkle_root))
-        |> Ethers.get_logs(fromBlock: @first_block)
+      |> Ethers.get_logs(fromBlock: @first_block)
 
     case event do
       {:error, reason} -> {:error, reason}
@@ -179,4 +213,18 @@ defmodule AlignedLayerServiceManager do
     end
   end
 
+  def get_current_gas_price() do
+    case Ethers.current_gas_price() do
+      {:ok, gas_price} ->
+        gas_price
+      {:error, error} -> raise("Error fetching gas price: #{error}")
+    end
+  end
+
+  def get_cost_per_proof() do
+    case Integer.parse(@gas_per_proof) do
+      {value, _} -> value * get_current_gas_price()
+      :error -> raise("Error parsing @gas_per_proof")
+    end
+  end
 end

explorer/lib/explorer/application.ex

@@ -9,6 +9,7 @@ defmodule Explorer.Application do
   def start(_type, _args) do
     children = [
       ExplorerWeb.Telemetry,
+      {Cachex, name: :eth_price_cache},
       {DNSCluster, query: Application.get_env(:explorer, :dns_cluster_query) || :ignore},
       {Phoenix.PubSub, name: Explorer.PubSub},
       # Start the Ecto db repository
@@ -29,6 +30,7 @@ defmodule Explorer.Application do
       {Explorer.Periodically, []},
       {Mutex, name: BatchMutex, meta: "Used to prevent concurrent downloads"}
     ]
+
     periodic_opts = [strategy: :one_for_all, name: Explorer.Periodically.Supervisor]
     Supervisor.start_link(periodic_children, periodic_opts)
   end

explorer/lib/explorer/avs_directory.ex

@@ -9,7 +9,7 @@ defmodule AVSDirectory do
   {status, config_json_string} = File.read(file_path)
 
   case status do
-    :ok -> Logger.debug("File read successfully")
+    :ok -> Logger.debug("Eigenlayer deployment file read successfully")
     :error -> raise("Config file not read successfully, did you run make create-env? If you did,\n make sure Eigenlayer config file is correctly stored")
   end
 

explorer/lib/explorer/models/batch_structs.ex

@@ -29,7 +29,8 @@ defmodule BatchDB do
     :submission_block_number,
     :submission_transaction_hash,
     :submission_timestamp,
-    :proof_hashes
+    :proof_hashes,
+    :cost_per_proof
   ]
   defstruct [
     :merkle_root,
@@ -42,6 +43,7 @@ defmodule BatchDB do
     :response_transaction_hash,
     :response_timestamp,
     :data_pointer,
-    :proof_hashes
+    :proof_hashes,
+    :cost_per_proof
   ]
 end

explorer/lib/explorer/models/batches.ex

@@ -14,15 +14,17 @@ defmodule Batches do
     field :response_transaction_hash, :string
     field :response_timestamp, :utc_datetime
     field :data_pointer, :string
+    # Elixir's default integer type effectively serves the same purpose as bigint, handling arbitrarily large integers out of the box.
+    field :cost_per_proof, :integer
 
     timestamps()
   end
 
   @doc false
   def changeset(new_batch, updates) do
     new_batch
-    |> cast(updates, [:merkle_root, :amount_of_proofs, :is_verified, :submission_block_number, :submission_transaction_hash, :submission_timestamp, :response_block_number, :response_transaction_hash, :response_timestamp, :data_pointer])
-    |> validate_required([:merkle_root, :amount_of_proofs, :is_verified, :submission_block_number, :submission_transaction_hash])
+    |> cast(updates, [:merkle_root, :amount_of_proofs, :is_verified, :submission_block_number, :submission_transaction_hash, :submission_timestamp, :response_block_number, :response_transaction_hash, :response_timestamp, :data_pointer, :cost_per_proof])
+    |> validate_required([:merkle_root, :amount_of_proofs, :is_verified, :submission_block_number, :submission_transaction_hash, :cost_per_proof])
     |> validate_format(:merkle_root, ~r/0x[a-fA-F0-9]{64}/)
     |> unique_constraint(:merkle_root)
     |> validate_number(:amount_of_proofs, greater_than: 0)
@@ -31,6 +33,7 @@ defmodule Batches do
     |> validate_format(:submission_transaction_hash, ~r/0x[a-fA-F0-9]{64}/)
     |> validate_number(:response_block_number, greater_than: 0)
     |> validate_format(:response_transaction_hash, ~r/0x[a-fA-F0-9]{64}/)
+    |> validate_number(:cost_per_proof, greater_than: 0)
   end
 
   def cast_to_batches(%BatchDB{} = batch_db) do
@@ -45,6 +48,7 @@ defmodule Batches do
       response_transaction_hash: batch_db.response_transaction_hash,
       response_timestamp: batch_db.response_timestamp,
       data_pointer: batch_db.data_pointer,
+      cost_per_proof: batch_db.cost_per_proof
     }
   end
 

explorer/lib/explorer/periodically.ex

@@ -12,36 +12,38 @@ defmodule Explorer.Periodically do
   end
 
   def send_work() do
-    seconds = 12 # once per block
-    :timer.send_interval(seconds * 1000, :work) # send every n seconds
+    # once per block
+    seconds = 12
+    # send every n seconds
+    :timer.send_interval(seconds * 1000, :work)
   end
 
   def handle_info(:work, count) do
     # Reads and process last n blocks for new batches or batch changes
-      read_block_qty = 8
-      latest_block_number = AlignedLayerServiceManager.get_latest_block_number()
-      read_from_block = max(0, latest_block_number - read_block_qty)
+    read_block_qty = 8
+    latest_block_number = AlignedLayerServiceManager.get_latest_block_number()
+    read_from_block = max(0, latest_block_number - read_block_qty)
 
     Task.start(fn -> process_blocks_from_to(read_from_block, latest_block_number) end)
 
     # Gets previous unverified batches and checks if they were verified
-      run_every_n_iterations = 8
-      new_count = rem(count + 1, run_every_n_iterations)
-      if new_count == 0 do
-        Task.start(&process_unverified_batches/0)
-      end
+    run_every_n_iterations = 8
+    new_count = rem(count + 1, run_every_n_iterations)
+    if new_count == 0 do
+      Task.start(&process_unverified_batches/0)
+    end
 
     {:noreply, new_count}
   end
 
   def process_blocks_from_to(fromBlock, toBlock) do
     "Processing from block #{fromBlock} to block #{toBlock}..." |> IO.inspect()
+
     try do
       AlignedLayerServiceManager.get_new_batch_events(%{fromBlock: fromBlock, toBlock: toBlock})
-        |> Enum.map(&AlignedLayerServiceManager.extract_batch_response/1)
-        # This function will avoid processing a batch taken by another process
-        |> Enum.map(&process_batch_if_not_in_other_process/1)
-
+      |> Enum.map(&AlignedLayerServiceManager.extract_batch_response/1)
+      # This function will avoid processing a batch taken by another process
+      |> Enum.map(&process_batch_if_not_in_other_process/1)
     rescue
       error -> IO.puts("An error occurred during batch processing:\n#{inspect(error)}")
     end
@@ -55,47 +57,58 @@ defmodule Explorer.Periodically do
     # one lock for each batch
     case Mutex.lock(BatchMutex, {batch.merkle_root}) do
       {:error, :busy} ->
-        "Batch already being processed: #{batch.merkle_root}" |> IO.inspect
+        "Batch already being processed: #{batch.merkle_root}" |> IO.inspect()
         nil
 
       {:ok, lock} ->
-        "Processing batch: #{batch.merkle_root}" |> IO.inspect
+        "Processing batch: #{batch.merkle_root}" |> IO.inspect()
+
         {batch_changeset, proofs} =
           batch
-            |> Utils.extract_info_from_data_pointer
-            |> Batches.generate_changesets
+          |> Utils.extract_info_from_data_pointer()
+          |> Batches.generate_changesets()
 
         Batches.insert_or_update(batch_changeset, proofs)
-          |> case do
-            {:ok, _} ->
-              IO.puts("Broadcasting update_views")
-              PubSub.broadcast(Explorer.PubSub, "update_views", %{})
-            {:error, error} ->
-              IO.puts("Some error in DB operation, not broadcasting update_views")
-              IO.inspect(error)
-            nil -> nil #no changes in DB
-          end
-
-        "Done processing batch: #{batch.merkle_root}" |> IO.inspect
+        |> case do
+          {:ok, _} ->
+            PubSub.broadcast(Explorer.PubSub, "update_views", %{
+              merkle_root: batch.merkle_root,
+              eth_usd:
+                case EthConverter.get_eth_price_usd() do
+                  {:ok, eth_usd_price} -> eth_usd_price
+                  {:error, _error} -> :empty
+                end
+            })
+
+          {:error, error} ->
+            IO.puts("Some error in DB operation, not broadcasting update_views")
+            IO.inspect(error)
+
+          # no changes in DB
+          nil ->
+            nil
+        end
+
+        "Done processing batch: #{batch.merkle_root}" |> IO.inspect()
         Mutex.release(BatchMutex, lock)
     end
   end
 
   defp process_unverified_batches() do
-    "verifying previous unverified batches..." |> IO.inspect()
+    "Verifying previous unverified batches..." |> IO.inspect()
     unverified_batches = Batches.get_unverified_batches()
 
     array_of_changest_tuples =
       unverified_batches
-        |> Enum.map(&AlignedLayerServiceManager.extract_batch_response/1)
-        |> Enum.reject(&is_nil/1)
-        |> Enum.map(&Batches.generate_changesets/1)
+      |> Enum.map(&AlignedLayerServiceManager.extract_batch_response/1)
+      |> Enum.reject(&is_nil/1)
+      |> Enum.map(&Batches.generate_changesets/1)
 
     Enum.map(
       array_of_changest_tuples,
       fn {batch_changeset, proofs} ->
         Batches.insert_or_update(batch_changeset, proofs)
-      end)
+      end
+    )
   end
-
 end