Store tx receipts

Makefile

@@ -15,3 +15,9 @@ stop-db:
 
 deps-get:
 	mix deps.get
+
+db_container := $(shell docker ps -aqf name=starknet_explorer_dev_db)
+seed: db
+	cat ./priv/repo/seed.sql | docker exec -i $(db_container) psql -U postgres -d starknet_explorer_dev
+create-seed: db
+	docker exec -i $(db_container) pg_dump --column-inserts --data-only -d starknet_explorer_dev -U postgres > ./priv/repo/seed.sql

lib/starknet_explorer/block.ex

@@ -2,7 +2,8 @@ defmodule StarknetExplorer.Block do
   use Ecto.Schema
   import Ecto.Query
   import Ecto.Changeset
-  alias StarknetExplorer.{Repo, Transaction}
+  alias StarknetExplorer.{Repo, Transaction, Block}
+  alias StarknetExplorer.TransactionReceipt, as: Receipt
   require Logger
   @primary_key {:number, :integer, []}
   schema "blocks" do
@@ -12,7 +13,7 @@ defmodule StarknetExplorer.Block do
     field :new_root, :string
     field :timestamp, :integer
     field :sequencer_address, :string
-    field :original_json, :binary
+    field :original_json, :binary, load_in_query: false
     has_many :transactions, StarknetExplorer.Transaction, foreign_key: :block_number
     timestamps()
   end
@@ -45,9 +46,10 @@ defmodule StarknetExplorer.Block do
   end
 
   @doc """
-  Given a block from the RPC response, insert it into the database.
+  Given a block from the RPC response, and transactions receipts
+  insert them into the DB.
   """
-  def insert_from_rpc_response(block = %{"transactions" => txs}) when is_map(block) do
+  def insert_from_rpc_response(block = %{"transactions" => txs}, receipts) when is_map(block) do
     # Store the original response, in case we need it
     # in the future, as a binary blob.
     original_json = :erlang.term_to_binary(block)
@@ -65,23 +67,31 @@ defmodule StarknetExplorer.Block do
       end)
       |> Map.put("original_json", original_json)
 
-    # Validate each transaction before inserting
-    # the block into postgres. I think
-    # this can be done with cast_assoc.
-    transactions =
-      txs
-      |> Enum.map(fn tx ->
-        Transaction.changeset(%Transaction{}, Map.put(tx, "block_number", block["number"]))
-      end)
+    transaction_result =
+      StarknetExplorer.Repo.transaction(fn ->
+        block_changeset = Block.changeset(%Block{original_json: original_json}, block)
+
+        {:ok, block} = Repo.insert(block_changeset)
 
-    changeset = changeset(%StarknetExplorer.Block{transactions: transactions}, block)
+        _txs_changeset =
+          Enum.map(txs, fn tx ->
+            tx =
+              Ecto.build_assoc(block, :transactions, tx)
+              |> Transaction.changeset(tx)
+              |> Repo.insert!()
 
-    case Repo.insert(changeset) do
+            Ecto.build_assoc(tx, :receipt, receipts[tx.hash])
+            |> Receipt.changeset(receipts[tx.hash])
+            |> Repo.insert!()
+          end)
+      end)
+
+    case transaction_result do
       {:ok, _} ->
         :ok
 
-      {:error, error} ->
-        Logger.error("Failed to insert block: #{inspect(error)}")
+      {:error, err} ->
+        Logger.error("Error inserting block: #{inspect(err)}")
         :error
     end
   end
@@ -101,4 +111,28 @@ defmodule StarknetExplorer.Block do
       [%{number: number}] -> number
     end
   end
+
+  @doc """
+  Returns the n latests blocks
+  """
+  def latest_n_blocks(n \\ 20) do
+    query =
+      from b in Block,
+        order_by: [desc: b.number],
+        limit: ^n
+
+    Repo.all(query)
+  end
+
+  @doc """
+  Returns the n latests blocks
+  """
+  def latest_n_blocks_with_txs(n \\ 20) do
+    query =
+      from b in Block,
+        order_by: [desc: b.number],
+        limit: ^n
+
+    Repo.all(query) |> Repo.preload(:transactions)
+  end
 end

lib/starknet_explorer/block_fetcher.ex

@@ -34,8 +34,15 @@ defmodule StarknetExplorer.BlockFetcher do
     # fetch a new block, else do nothing.
     if curr_height + 10 >= state.latest_block_fetched do
       case fetch_block(state.latest_block_fetched + 1) do
-        {:ok, block = %{"block_number" => new_block_number}} ->
-          :ok = Block.insert_from_rpc_response(block)
+        {:ok, block = %{"block_number" => new_block_number, "transactions" => transactions}} ->
+          receipts =
+            transactions
+            |> Map.new(fn %{"transaction_hash" => tx_hash} ->
+              {:ok, receipt} = Rpc.get_transaction_receipt(tx_hash)
+              {tx_hash, receipt}
+            end)
+
+          :ok = Block.insert_from_rpc_response(block, receipts)
           Logger.info("Inserted new block: #{new_block_number}")
           Process.send_after(self(), :fetch_and_store, @fetch_interval)
           {:noreply, %{state | block_height: curr_height, latest_block_fetched: new_block_number}}

lib/starknet_explorer/transaction.ex

@@ -1,6 +1,8 @@
 defmodule StarknetExplorer.Transaction do
   use Ecto.Schema
   import Ecto.Changeset
+  import Ecto.Query
+  alias StarknetExplorer.{Transaction, Repo, TransactionReceipt}
 
   @l1_handler_tx_fields [
     :hash,
@@ -27,7 +29,6 @@
   @invoke_v1_tx_fields [
     :calldata,
     :sender_address,
-    :entry_point_selector,
     :hash,
     :max_fee,
     :nonce,
@@ -65,16 +66,15 @@
     :nonce,
     :signature,
     :type,
-    :type,
     :version
   ]
 
   @fields @l1_handler_tx_fields ++
             @invoke_tx_fields ++
             @declare_tx_fields ++ @deploy_contract_tx_fields ++ @deploy_account_tx_fields
 
-  @primary_key {:hash, :string, []}
   schema "transactions" do
+    field :hash, :string
     field :constructor_calldata, {:array, :string}
     field :class_hash, :string
     field :type, :string
@@ -91,23 +91,33 @@
     field :sender_address, :string
     field :calldata, {:array, :string}
     belongs_to :block, StarknetExplorer.Block, foreign_key: :block_number
+    has_one :receipt, TransactionReceipt
     timestamps()
   end
 
-  def changeset(tx, attrs) do
+  def changeset(tx, attrs = %{"transaction_hash" => hash}) do
     attrs = rename_rpc_fields(attrs)
 
     tx
     |> cast(
       attrs,
       @fields
     )
+    |> Ecto.Changeset.change(%{hash: hash})
+    |> unique_constraint([:hash])
     |> validate_according_to_tx_type(attrs)
-    |> unique_constraint(:hash)
+  end
+
+  def get_by_hash(hash) do
+    query =
+      from tx in Transaction,
+        where: tx.hash == ^hash
+
+    Repo.one!(query)
   end
 
   defp rename_rpc_fields(rpc_tx = %{"transaction_hash" => th}) do
-    rpc_tx |> Map.put("hash", th)
+    rpc_tx |> Map.delete("transaction_hash") |> Map.put("hash", th)
   end
 
   defp validate_according_to_tx_type(changeset, _tx = %{"type" => "INVOKE", "version" => "0x1"}) do
@@ -120,12 +130,17 @@
     |> validate_required(@invoke_tx_fields)
   end
 
-  defp validate_according_to_tx_type(changeset, tx = %{"type" => "DEPLOY", "max_fee" => _}) do
+  defp validate_according_to_tx_type(changeset, _tx = %{"type" => "DEPLOY", "max_fee" => _}) do
+    changeset
+    |> validate_required(@deploy_account_tx_fields)
+  end
+
+  defp validate_according_to_tx_type(changeset, _tx = %{"type" => "DEPLOY_ACCOUNT"}) do
     changeset
     |> validate_required(@deploy_account_tx_fields)
   end
 
-  defp validate_according_to_tx_type(changeset, tx = %{"type" => "DEPLOY"}) do
+  defp validate_according_to_tx_type(changeset, _tx = %{"type" => "DEPLOY"}) do
     changeset
     |> validate_required(@deploy_contract_tx_fields)
   end

lib/starknet_explorer/transaction_receipt.ex

@@ -0,0 +1,147 @@
+defmodule StarknetExplorer.TransactionReceipt do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias StarknetExplorer.{Transaction, TransactionReceipt}
+
+  @invoke_tx_receipt_fields [
+    :type,
+    :transaction_hash,
+    :actual_fee,
+    :status,
+    :messages_sent,
+    :events,
+    :block_hash,
+    :block_number,
+    :messages_sent,
+    :events
+  ]
+
+  @l1_receipt_handler [
+    :type,
+    :transaction_hash,
+    :actual_fee,
+    :status,
+    :block_hash,
+    :block_number,
+    :messages_sent,
+    :events
+  ]
+
+  @declare_tx_receipt [
+    :type,
+    :transaction_hash,
+    :actual_fee,
+    :status,
+    :block_hash,
+    :block_number,
+    :messages_sent,
+    :events
+  ]
+
+  @deploy_tx_receipt [
+    :transaction_hash,
+    :actual_fee,
+    :status,
+    :block_hash,
+    :messages_sent,
+    :events,
+    :type,
+    :contract_address
+  ]
+
+  @deploy_account_tx_receipt [
+    :transaction_hash,
+    :actual_fee,
+    :status,
+    :block_hash,
+    :block_number,
+    :messages_sent,
+    :events,
+    :type,
+    :contract_address
+  ]
+
+  # @pending_receipt [
+  #   :transaction_hash,
+  #   :actual_fee,
+  #   :type,
+  #   :messages_sent,
+  #   :events,
+  #   :contract_address
+  # ]
+
+  # @pending_deploy_receipt [
+  #   :transaction_hash,
+  #   :type,
+  #   :actual_fee,
+  #   :messages_sent,
+  #   :events,
+  #   :contract_address
+  # ]
+
+  @fields @invoke_tx_receipt_fields ++
+            @l1_receipt_handler ++ @declare_tx_receipt ++ @deploy_account_tx_receipt
+  schema "transaction_receipts" do
+    belongs_to :transaction, Transaction
+    field :transaction_hash
+    field :type, :string
+    field :actual_fee, :string
+    field :status, :string
+    field :block_hash, :string
+    field :block_number, :integer
+    field :messages_sent, {:array, :map}
+    field :events, {:array, :map}
+    field :contract_address
+    timestamps()
+  end
+
+  def changeset(receipt, attrs) do
+    receipt
+    |> cast(
+      attrs,
+      @fields
+    )
+    |> validate_according_to_type(attrs)
+
+    # |> foreign_key_constraint(:transaction_id)
+    # |> unique_constraint([:id])
+    # |> dbg
+  end
+
+  # TODO: Use the proper changeset function
+  def changeset_for_assoc(attrs = %{"transaction_hash" => hash}) do
+    %TransactionReceipt{}
+    |> Ecto.Changeset.change()
+    |> cast(
+      attrs,
+      @fields
+    )
+    |> validate_according_to_type(attrs)
+    |> unique_constraint(:receipt)
+  end
+
+  defp validate_according_to_type(changeset, _tx = %{"type" => "INVOKE"}) do
+    changeset
+    |> validate_required(@invoke_tx_receipt_fields)
+  end
+
+  defp validate_according_to_type(changeset, _tx = %{"type" => "L1_HANDLER"}) do
+    changeset
+    |> validate_required(@l1_receipt_handler)
+  end
+
+  defp validate_according_to_type(changeset, _tx = %{"type" => "DECLARE"}) do
+    changeset
+    |> validate_required(@declare_tx_receipt)
+  end
+
+  defp validate_according_to_type(changeset, _tx = %{"type" => "DEPLOY"}) do
+    changeset
+    |> validate_required(@deploy_tx_receipt)
+  end
+
+  defp validate_according_to_type(changeset, _tx = %{"type" => "DEPLOY_ACCOUNT"}) do
+    changeset
+    |> validate_required(@deploy_account_tx_receipt)
+  end
+end

lib/starknet_explorer_web/live/block_index_live.ex

@@ -1,7 +1,7 @@
 defmodule StarknetExplorerWeb.BlockIndexLive do
   use StarknetExplorerWeb, :live_view
   alias StarknetExplorerWeb.Utils
-
+  alias StarknetExplorer.Block
   @impl true
   def render(assigns) do
     ~H"""

priv/repo/migrations/20230704215332_transactions.exs

@@ -2,7 +2,7 @@ defmodule StarknetExplorer.Repo.Migrations.Transactions do
   use Ecto.Migration
 
   def change do
-    create table("transactions", primary_key: false) do
+    create table("transactions") do
       add :block_number,
           references("blocks",
             on_delete: :delete_all,
@@ -22,7 +22,7 @@ defmodule StarknetExplorer.Repo.Migrations.Transactions do
       add :compiled_class_hash, :string
       add :sender_address, :string
       add :entry_point_selector, :string
-      add :hash, :string, primary_key: true
+      add :hash, :string
       add :max_fee, :string
       add :nonce, :string
       add :signature, {:array, :string}