fix: render binary pointer key on name related endpoints (#1004)

Author: jyeshe

lib/ae_mdw/db/format.ex

@@ -91,6 +91,22 @@ defmodule AeMdw.Db.Format do
     }
   end
 
+  @spec encode_pointers(list() | map()) :: %{iodata() => String.t()}
+  def encode_pointers(pointers) when is_map(pointers) do
+    Enum.into(pointers, %{}, fn {key, id} -> {maybe_base64_pointer_key(key), enc_id(id)} end)
+  end
+
+  def encode_pointers(pointers) do
+    Enum.map(pointers, fn
+      %{"key" => key, "id" => id} -> %{"key" => maybe_base64_pointer_key(key), "id" => id}
+      %{key: key, id: id} -> %{key: maybe_base64_pointer_key(key), id: id}
+    end)
+  end
+
+  @spec enc_id(aeser_id() | nil) :: nil | String.t()
+  def enc_id(nil), do: nil
+  def enc_id({:id, _type, _pk} = id), do: Enc.encode(:id_hash, id)
+
   defp custom_raw_data(_state, :contract_create_tx, tx, tx_rec, _signed_tx, block_hash) do
     init_call_details = Contract.get_init_call_details(tx_rec, block_hash)
 
@@ -134,8 +150,11 @@ defmodule AeMdw.Db.Format do
     put_in(tx, [:tx, :name_id], :aeser_id.create(:name, name_id))
   end
 
-  defp custom_raw_data(state, :name_update_tx, tx, tx_rec, _signed_tx, _block_hash),
-    do: put_in(tx, [:tx, :name], Name.plain_name!(state, :aens_update_tx.name_hash(tx_rec)))
+  defp custom_raw_data(state, :name_update_tx, tx, tx_rec, _signed_tx, _block_hash) do
+    tx
+    |> put_in([:tx, :name], Name.plain_name!(state, :aens_update_tx.name_hash(tx_rec)))
+    |> update_in([:tx, :pointers], &encode_pointers/1)
+  end
 
   defp custom_raw_data(state, :name_transfer_tx, tx, tx_rec, _signed_tx, _block_hash),
     do: put_in(tx, [:tx, :name], Name.plain_name!(state, :aens_transfer_tx.name_hash(tx_rec)))
@@ -189,9 +208,9 @@ defmodule AeMdw.Db.Format do
         end
       )
 
-    raw_to_json(raw_map)
+    raw_map
+    |> raw_to_json()
     |> put_in(["auction"], auction)
-    |> update_in(["status"], &to_string/1)
   end
 
   def to_map(state, {call_txi, local_idx}, Model.IntContractCall) do
@@ -353,8 +372,11 @@ defmodule AeMdw.Db.Format do
     put_in(tx, ["name_id"], Enc.encode(:name, name_id))
   end
 
-  defp custom_encode(state, :name_update_tx, tx, tx_rec, _signed_tx, _txi, _block_hash),
-    do: put_in(tx, ["name"], Name.plain_name!(state, :aens_update_tx.name_hash(tx_rec)))
+  defp custom_encode(state, :name_update_tx, tx, tx_rec, _signed_tx, _txi, _block_hash) do
+    tx
+    |> put_in(["name"], Name.plain_name!(state, :aens_update_tx.name_hash(tx_rec)))
+    |> update_in(["pointers"], &encode_pointers/1)
+  end
 
   defp custom_encode(state, :name_transfer_tx, tx, tx_rec, _signed_tx, _txi, _block_hash),
     do: put_in(tx, ["name"], Name.plain_name!(state, :aens_transfer_tx.name_hash(tx_rec)))
@@ -365,6 +387,12 @@ defmodule AeMdw.Db.Format do
   defp custom_encode(_state, _tx_type, tx, _tx_rec, _signed_tx, _txi, _block_hash),
     do: tx
 
+  defp maybe_base64_pointer_key(key)
+       when key in ["account_pubkey", "oracle_pubkey", "contract_pubkey", "channel"],
+       do: key
+
+  defp maybe_base64_pointer_key(key), do: Base.encode64(key)
+
   defp maybe_base64(bin) do
     try do
       dec = :base64.decode(bin)
@@ -382,12 +410,6 @@ defmodule AeMdw.Db.Format do
     end
   end
 
-  @spec enc_id(aeser_id() | nil) :: binary() | nil
-  def enc_id(nil), do: nil
-
-  def enc_id({:id, idtype, payload}),
-    do: Enc.encode(AE.id_type(idtype), payload)
-
   defp raw_to_json(x),
     do: map_raw_values(x, &to_json/1)
 

lib/ae_mdw/db/name.ex

@@ -144,8 +144,8 @@ defmodule AeMdw.Db.Name do
       end
 
     pointers
-    |> Stream.map(&pointer_kv_raw/1)
-    |> Enum.into(%{})
+    |> Enum.into(%{}, &pointer_kv_raw/1)
+    |> Format.encode_pointers()
   end
 
   @spec ownership(state(), Model.name()) :: %{

lib/ae_mdw/names.ex

@@ -433,18 +433,11 @@ defmodule AeMdw.Names do
       transfers: Enum.map(transfers, &expand_txi(state, &1, opts)),
       revoke: (revoke && expand_txi(state, revoke, opts)) || nil,
       auction_timeout: auction_timeout,
-      pointers: render_pointers(state, name),
+      pointers: Name.pointers(state, name),
       ownership: render_ownership(state, name)
     }
   end
 
-  defp render_pointers(state, name) do
-    state
-    |> Name.pointers(name)
-    |> Enum.map(fn {key, id} -> {key, Format.enc_id(id)} end)
-    |> Enum.into(%{})
-  end
-
   defp render_ownership(state, name) do
     %{current: current_owner, original: original_owner} = Name.ownership(state, name)
 

lib/ae_mdw_web/controllers/name_controller.ex

@@ -171,7 +171,7 @@ defmodule AeMdwWeb.NameController do
   defp pointers_reply(%Conn{assigns: %{state: state}} = conn, plain_name) do
     case Name.locate(state, plain_name) do
       {m_name, Model.ActiveName} ->
-        json(conn, Format.map_raw_values(Name.pointers(state, m_name), &Format.to_json/1))
+        json(conn, Name.pointers(state, m_name))
 
       {_m_name, Model.InactiveName} ->
         raise ErrInput.Expired, value: plain_name

test/ae_mdw/db/name_test.exs

@@ -0,0 +1,137 @@
+defmodule AeMdw.Db.NameTest do
+  use ExUnit.Case, async: false
+
+  alias AeMdw.Db.Format
+  alias AeMdw.Db.Model
+  alias AeMdw.Db.MemStore
+  alias AeMdw.Db.Name
+  alias AeMdw.Db.NullStore
+  alias AeMdw.Db.State
+  alias AeMdw.Db.Store
+
+  import Mock
+
+  require Model
+
+  describe "pointers/2" do
+    test "encodes non-string pointer key to base64" do
+      name = "binarypointer.chain"
+      pointer_id = :aeser_id.create(:account, <<1::256>>)
+      oracle_id = :aeser_id.create(:oracle, <<1::256>>)
+
+      non_string_pointer_key =
+        <<104, 65, 117, 174, 49, 251, 29, 202, 69, 174, 147, 56, 60, 150, 188, 247, 149, 85, 150,
+          148, 88, 102, 186, 208, 87, 101, 78, 111, 189, 5, 144, 101>>
+
+      non_string_pointer_key64 = Base.encode64(non_string_pointer_key)
+
+      tx_hash = :crypto.strong_rand_bytes(32)
+
+      with_mocks [
+        {AeMdw.Node.Db, [:passthrough],
+         [
+           get_tx_data: fn ^tx_hash ->
+             {:ok, name_hash} = :aens.get_name_hash(name)
+
+             {:ok, aetx} =
+               :aens_update_tx.new(%{
+                 account_id: :aeser_id.create(:account, <<2::256>>),
+                 nonce: 1,
+                 name_id: :aeser_id.create(:name, name_hash),
+                 name_ttl: 1_000,
+                 pointers: [
+                   {:pointer, non_string_pointer_key, pointer_id},
+                   {:pointer, "oracle_pubkey", oracle_id}
+                 ],
+                 client_ttl: 1_000,
+                 fee: 5_000
+               })
+
+             {_mod, tx_rec} = :aetx.specialize_type(aetx)
+             {nil, :name_update_tx, nil, tx_rec}
+           end
+         ]}
+      ] do
+        store =
+          NullStore.new()
+          |> MemStore.new()
+          |> Store.put(
+            Model.Tx,
+            Model.tx(index: 2, id: tx_hash, block_index: {1, 1})
+          )
+
+        pointers_map = %{
+          non_string_pointer_key64 => Format.enc_id(pointer_id),
+          "oracle_pubkey" => Format.enc_id(oracle_id)
+        }
+
+        assert ^pointers_map =
+                 Name.pointers(
+                   State.new(store),
+                   Model.name(
+                     index: name,
+                     updates: [{{1, 1}, 2}]
+                   )
+                 )
+      end
+    end
+
+    test "encodes custom string pointer key to base64" do
+      name = "binarypointer.chain"
+      pointer_id = :aeser_id.create(:account, <<1::256>>)
+      channel_id = :aeser_id.create(:channel, <<2::256>>)
+      custom_string_pointer_key = "family_pubkey"
+      custom_string_pointer_key64 = Base.encode64(custom_string_pointer_key)
+
+      tx_hash = :crypto.strong_rand_bytes(32)
+
+      with_mocks [
+        {AeMdw.Node.Db, [:passthrough],
+         [
+           get_tx_data: fn ^tx_hash ->
+             {:ok, name_hash} = :aens.get_name_hash(name)
+
+             {:ok, aetx} =
+               :aens_update_tx.new(%{
+                 account_id: :aeser_id.create(:account, <<2::256>>),
+                 nonce: 1,
+                 name_id: :aeser_id.create(:name, name_hash),
+                 name_ttl: 1_000,
+                 pointers: [
+                   {:pointer, "channel", channel_id},
+                   {:pointer, custom_string_pointer_key, pointer_id}
+                 ],
+                 client_ttl: 1_000,
+                 fee: 5_000
+               })
+
+             {_mod, tx_rec} = :aetx.specialize_type(aetx)
+             {nil, :name_update_tx, nil, tx_rec}
+           end
+         ]}
+      ] do
+        store =
+          NullStore.new()
+          |> MemStore.new()
+          |> Store.put(
+            Model.Tx,
+            Model.tx(index: 2, id: tx_hash, block_index: {1, 1})
+          )
+
+        pointers_map = %{
+          custom_string_pointer_key64 => Format.enc_id(pointer_id),
+          "channel" => Format.enc_id(channel_id)
+        }
+
+        assert ^pointers_map =
+                 Name.pointers(
+                   State.new(store),
+                   Model.name(
+                     index: name,
+                     updates: [{{1, 1}, 2}]
+                   )
+                 )
+      end
+    end
+  end
+end

test/ae_mdw_web/controllers/tx_controller_test.exs

@@ -8,7 +8,7 @@ defmodule AeMdwWeb.TxControllerTest do
   alias AeMdw.Node.Db
   alias AeMdw.TestSamples, as: TS
 
-  import AeMdwWeb.BlockchainSim, only: [with_blockchain: 3, tx: 3, name_tx: 3]
+  import AeMdwWeb.BlockchainSim, only: [with_blockchain: 3, tx: 3, name_tx: 3, name_tx: 4]
   import AeMdw.Util.Encoding
   import Mock
 
@@ -299,6 +299,60 @@ defmodule AeMdwWeb.TxControllerTest do
                  |> json_response(200)
       end
     end
+
+    test "returns a name_update_tx with non-string pointers", %{conn: conn, store: store} do
+      plain_name = "aliceinchains.chain"
+      {:ok, name_hash} = :aens.get_name_hash(plain_name)
+
+      non_string_pointer_key =
+        <<104, 65, 117, 174, 49, 251, 29, 202, 69, 174, 147, 56, 60, 150, 188, 247, 149, 85, 150,
+          148, 88, 102, 186, 208, 87, 101, 78, 111, 189, 5, 144, 101>>
+
+      non_string_pointer_key64 = Base.encode64(non_string_pointer_key)
+
+      with_blockchain %{alice1: 1_000, alice2: 1_000},
+        mb: [
+          tx:
+            name_tx(:name_update_tx, :alice1, plain_name, %{
+              pointers: [{:pointer, non_string_pointer_key, :alice2}]
+            })
+        ] do
+        %{txs: [tx]} = blocks[:mb]
+        {:id, :account, alice_pk1} = accounts[:alice1]
+        {:id, :account, alice_pk2} = accounts[:alice2]
+        alice_id1 = encode(:account_pubkey, alice_pk1)
+        alice_id2 = encode(:account_pubkey, alice_pk2)
+
+        store =
+          store
+          |> Store.put(Model.Tx, Model.tx(index: 1, block_index: {0, 0}, id: :aetx_sign.hash(tx)))
+          |> Store.put(Model.PlainName, Model.plain_name(index: name_hash, value: plain_name))
+          |> Store.put(Model.ActiveName, Model.name(index: plain_name))
+          |> Store.put(Model.Block, Model.block(index: {0, -1}, tx_index: 1))
+          |> Store.put(Model.Block, Model.block(index: {0, 0}, tx_index: 1))
+          |> Store.put(Model.Block, Model.block(index: {1, -1}, tx_index: 2))
+
+        tx_hash = encode(:tx_hash, :aetx_sign.hash(tx))
+
+        assert %{
+                 "hash" => ^tx_hash,
+                 "tx" => %{
+                   "account_id" => ^alice_id1,
+                   "name" => ^plain_name,
+                   "pointers" => [
+                     %{
+                       "id" => ^alice_id2,
+                       "key" => ^non_string_pointer_key64
+                     }
+                   ]
+                 }
+               } =
+                 conn
+                 |> with_store(store)
+                 |> get("/v2/txs/#{tx_hash}")
+                 |> json_response(200)
+      end
+    end
   end
 
   describe "count" do

test/integration/ae_mdw_web/controllers/name_controller_test.exs

@@ -1241,7 +1241,7 @@ defmodule Integration.AeMdwWeb.NameControllerTest do
 
     case Name.locate(state, name) do
       {m_name, Model.ActiveName} ->
-        Format.map_raw_values(Name.pointers(state, m_name), &Format.to_json/1)
+        Name.pointers(state, m_name)
 
       {_info, Model.InactiveName} ->
         raise ErrInput.Expired, value: name

test/support/blockchain_sim.ex

@@ -371,10 +371,25 @@ defmodule AeMdwWeb.BlockchainSim do
     {:id, :account, pubkey} = account_id = Map.fetch!(accounts, account_name)
     {:ok, name_hash} = :aens.get_name_hash(plain_name)
 
-    pointers = [
-      {:pointer, "account_pubkey", account_id},
-      {:pointer, "oracle_pubkey", :aeser_id.create(:oracle, pubkey)}
-    ]
+    pointers =
+      case args[:pointers] do
+        nil ->
+          [
+            {:pointer, "account_pubkey", account_id},
+            {:pointer, "oracle_pubkey", :aeser_id.create(:oracle, pubkey)}
+          ]
+
+        list ->
+          Enum.map(list, fn
+            {:pointer, key, account_atom} when is_atom(account_atom) ->
+              {:pointer, key, Map.fetch!(accounts, account_atom)}
+
+            another_pointer ->
+              another_pointer
+          end)
+      end
+
+    args = Map.delete(args, :pointers)
 
     %{
       account_id: account_id,