Show data from DB

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

README.md

@@ -28,6 +28,11 @@ make setup run
 ```
 
 This will start postgres, create the database and start a web app in `localhost:4000`.
+For local development, you can seed the db with
+
+```
+make seed
+```
 
 From now on, if you want to restart the app, you can just do:
 ```

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!()
+
+            Ecto.build_assoc(tx, :receipt, receipts[tx.hash])
+            |> Receipt.changeset(receipts[tx.hash])
+            |> Repo.insert!()
+          end)
+      end)
 
-    case Repo.insert(changeset) do
+    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,46 @@ 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
+
+  def get_by_hash_with_txs(hash) do
+    query =
+      from b in Block,
+        where: b.hash == ^hash,
+        preload: :transactions
+
+    Repo.one(query)
+  end
+
+  def get_by_num_with_txs(number) do
+    query =
+      from b in Block,
+        where: b.number == ^number,
+        preload: :transactions
+
+    Repo.one(query)
+  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 @@ defmodule StarknetExplorer.Transaction do
   @invoke_v1_tx_fields [
     :calldata,
     :sender_address,
-    :entry_point_selector,
     :hash,
     :max_fee,
     :nonce,
@@ -65,16 +66,15 @@ defmodule StarknetExplorer.Transaction do
     :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,34 @@ defmodule StarknetExplorer.Transaction do
     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_with_receipt(hash) do
+    query =
+      from tx in Transaction,
+        where: tx.hash == ^hash,
+        preload: [:receipt]
+
+    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 +131,17 @@ defmodule StarknetExplorer.Transaction do
     |> 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