feat: render call details for ga_attach and ga_meta (#972)

Author: jyeshe

lib/ae_mdw/contract.ex

@@ -49,7 +49,8 @@ defmodule AeMdw.Contract do
           return: any()
         }
   @type fun_arg_res_or_error :: fun_arg_res() | {:error, any()}
-  @type local_idx() :: non_neg_integer()
+  @type local_idx :: non_neg_integer()
+  @typep pubkey :: DBN.pubkey()
   @typep tx :: Node.tx()
   @typep signed_tx :: Node.signed_tx()
   @typep block_hash :: <<_::256>>
@@ -298,6 +299,18 @@ defmodule AeMdw.Contract do
     |> Map.put("source_hash", source_hash && Base.encode64(source_hash))
   end
 
+  @spec get_ga_attach_call_details(signed_tx(), pubkey(), block_hash()) :: serialized_call()
+  def get_ga_attach_call_details(signed_tx, contract_pk, block_hash) do
+    call_rec = call_rec(signed_tx, contract_pk, block_hash)
+    {mod, tx_rec} = signed_tx |> :aetx_sign.tx() |> :aetx.specialize_callback()
+
+    %{
+      "args" => contract_init_args(contract_pk, tx_rec, mod),
+      "gas_used" => :aect_call.gas_used(call_rec),
+      "return_type" => :aect_call.return_type(call_rec)
+    }
+  end
+
   @spec stringfy_log_topics([map()]) :: [map()]
   def stringfy_log_topics(logs) do
     Enum.map(logs, fn log ->
@@ -430,9 +443,9 @@ defmodule AeMdw.Contract do
     end
   end
 
-  defp contract_init_args(contract_pk, tx_rec) do
+  defp contract_init_args(contract_pk, tx_rec, mod \\ :aect_create_tx) do
     with {:ok, {type_info, _compiler_vsn, _source_hash}} <- get_info(contract_pk),
-         call_data <- :aect_create_tx.call_data(tx_rec),
+         call_data <- mod.call_data(tx_rec),
          {"init", args} <- decode_call_data(type_info, call_data) do
       args_type_value(args)
     else

lib/ae_mdw/db/format.ex

@@ -285,11 +285,11 @@ defmodule AeMdw.Db.Format do
 
   defp custom_encode(_state, :ga_attach_tx, tx, tx_rec, signed_tx, _txi, block_hash) do
     contract_pk = :aega_attach_tx.contract_pubkey(tx_rec)
-    call_rec = Contract.call_rec(signed_tx, contract_pk, block_hash)
+    call_details = Contract.get_ga_attach_call_details(signed_tx, contract_pk, block_hash)
 
     tx
     |> Map.put("contract_id", Enc.encode(:contract_pubkey, contract_pk))
-    |> Map.put("return_type", :aect_call.return_type(call_rec))
+    |> Map.merge(call_details)
   end
 
   defp custom_encode(_state, :ga_meta_tx, tx, tx_rec, _signed_tx, _txi, block_hash) do
@@ -298,10 +298,14 @@ defmodule AeMdw.Db.Format do
 
     case :aec_chain.get_ga_call(owner_pk, auth_id, block_hash) do
       {:ok, ga_object} ->
-        Map.put(tx, "return_type", :aega_call.return_type(ga_object))
+        tx
+        |> Map.put("return_type", :aega_call.return_type(ga_object))
+        |> Map.put("gas_used", :aega_call.gas_used(ga_object))
 
       _error_revert ->
-        Map.put(tx, "return_type", :unknown)
+        tx
+        |> Map.put("return_type", :unknown)
+        |> Map.put("gas_used", nil)
     end
   end
 

test/ae_mdw_web/controllers/tx_controller_test.exs

@@ -9,6 +9,7 @@ defmodule AeMdwWeb.TxControllerTest do
   alias AeMdw.TestSamples, as: TS
 
   import AeMdwWeb.BlockchainSim, only: [with_blockchain: 3, tx: 3]
+  import AeMdw.Util.Encoding
   import Mock
 
   require Model
@@ -52,35 +53,67 @@ defmodule AeMdwWeb.TxControllerTest do
       end
     end
 
-    test "returns an ga_attach_tx with return_type", %{
+    test "returns an ga_attach_tx with call details", %{
       conn: conn,
       store: store
     } do
       nonce = 3
 
+      call_data =
+        <<43, 17, 68, 214, 68, 31, 27, 159, 1, 81, 36, 174, 134, 247, 199, 24, 36, 209, 93, 111,
+          71, 91, 175, 20, 235, 201, 171, 175, 148, 138>>
+
       with_blockchain %{ga: 10_000},
         mb: [
-          ga_tx: tx(:ga_attach_tx, :ga, %{nonce: nonce})
+          ga_tx: tx(:ga_attach_tx, :ga, %{nonce: nonce, call_data: call_data})
         ] do
-        %{txs: [tx]} = blocks[:mb]
+        %{txs: [signed_tx]} = blocks[:mb]
         {:id, :account, account_pk} = accounts[:ga]
         account_id = encode(:account_pubkey, account_pk)
         mb_hash = :crypto.strong_rand_bytes(32)
 
         store =
           store
-          |> Store.put(Model.Tx, Model.tx(index: 1, block_index: {0, 0}, id: :aetx_sign.hash(tx)))
+          |> Store.put(
+            Model.Tx,
+            Model.tx(index: 1, block_index: {0, 0}, id: :aetx_sign.hash(signed_tx))
+          )
           |> Store.put(Model.Block, Model.block(index: {0, -1}, tx_index: 1))
           |> Store.put(Model.Block, Model.block(index: {0, 0}, hash: mb_hash, tx_index: 1))
           |> Store.put(Model.Block, Model.block(index: {1, -1}, tx_index: 2))
 
-        tx_hash = encode(:tx_hash, :aetx_sign.hash(tx))
+        functions = %{
+          <<68, 214, 68, 31>> =>
+            {[], {[bytes: 20], {:tuple, []}},
+             %{
+               0 => [
+                 {:STORE, {:var, -1}, {:immediate, 1}},
+                 {:STORE, {:var, -2}, {:arg, 0}},
+                 {:RETURNR, {:immediate, {:tuple, {}}}}
+               ]
+             }}
+        }
+
+        type_info = {:fcode, functions, %{<<68, 214, 68, 31>> => "init"}, nil}
+        {_mod, tx} = signed_tx |> :aetx_sign.tx() |> :aetx.specialize_callback()
+        contract_pk = :aega_attach_tx.contract_pubkey(tx)
+
+        AeMdw.EtsCache.put(AeMdw.Contract, contract_pk, {type_info, nil, nil})
+
+        tx_hash = encode(:tx_hash, :aetx_sign.hash(signed_tx))
+
+        {:tuple, {_fun_hash, {:tuple, {{:bytes, arg_bytes}}}}} =
+          :aeb_fate_encoding.deserialize(call_data)
+
+        bytes_arg = encode(:bytearray, arg_bytes)
 
         assert %{
                  "hash" => ^tx_hash,
                  "tx" => %{
                    "nonce" => ^nonce,
                    "owner_id" => ^account_id,
+                   "args" => [%{"type" => "bytes", "value" => ^bytes_arg}],
+                   "gas_used" => 1_000,
                    "return_type" => "ok",
                    "type" => "GAAttachTx"
                  }
@@ -120,7 +153,8 @@ defmodule AeMdwWeb.TxControllerTest do
                  "hash" => ^tx_hash,
                  "tx" => %{
                    "ga_id" => ^account_id,
-                   "return_type" => "some_return_type",
+                   "gas_used" => 2_000,
+                   "return_type" => "ok",
                    "tx" => %{
                      "tx" => %{
                        "sender_id" => ^account_id,

test/support/blockchain_sim.ex

@@ -54,11 +54,12 @@ defmodule AeMdwWeb.BlockchainSim do
             if ga_tx_hash do
               [
                 {:aec_chain, [:passthrough],
-                 get_ga_call: fn ^ga_pk, _auth_id, _block_hash -> {:ok, ga_tx_hash} end,
-                 get_contract_call: fn _pk, _call_id, ^block_hash ->
+                 get_ga_call: fn ^ga_pk, _auth_id, _block_hash ->
+                   {:ok, :aega_call.new({:id, :account, ga_pk}, ga_pk, 1, 10_000, 2_000, :ok, "")}
+                 end,
+                 get_contract_call: fn _ga_pk, _call_id, ^block_hash ->
                    {:ok, call_rec("attach", ga_pk)}
-                 end},
-                {:aega_call, [:passthrough], return_type: fn ^ga_tx_hash -> :some_return_type end}
+                 end}
               ]
             else
               []