refactor: generalize aexn create contract mutation (#699)

Author: jyeshe

lib/ae_mdw/aex9.ex

@@ -4,6 +4,7 @@ defmodule AeMdw.Aex9 do
   """
 
   alias AeMdw.Collection
+  alias AeMdw.Contracts.AexnContract
   alias AeMdw.Database
   alias AeMdw.Db.Format
   alias AeMdw.Db.Model
@@ -111,7 +112,7 @@ defmodule AeMdw.Aex9 do
           {:ok, balances_cursor() | nil, [aex9_balance()], balances_cursor() | nil}
           | {:error, Error.t()}
   def fetch_balances(contract_pk, pagination, cursor) do
-    if AeMdw.Contract.is_aex9?(contract_pk) do
+    if AexnContract.is_aex9?(contract_pk) do
       {amounts, _height_hash} = Db.aex9_balances!(contract_pk)
       accounts_pks = amounts |> Map.keys() |> Enum.sort()
       cursor = deserialize_balances_cursor(cursor)
@@ -388,7 +389,7 @@ defmodule AeMdw.Aex9 do
   end
 
   defp validate_aex9(contract_pk) do
-    if AeMdw.Contract.is_aex9?(contract_pk) do
+    if AexnContract.is_aex9?(contract_pk) do
       :ok
     else
       {:error,

lib/ae_mdw/contract.ex

@@ -8,8 +8,6 @@ defmodule AeMdw.Contract do
   alias AeMdw.Node
   alias AeMdw.Node.Db, as: DBN
   alias AeMdw.DryRun
-  alias AeMdw.Log
-  alias AeMdw.Validate
 
   import :erlang, only: [tuple_to_list: 1]
 
@@ -35,7 +33,6 @@ defmodule AeMdw.Contract do
 
   @type call :: tuple()
 
-  @type aex9_meta_info() :: {String.t(), String.t(), integer()}
   # for balances or balance
   @type call_result :: map() | tuple()
   @type serialized_call :: map()
@@ -58,10 +55,6 @@ defmodule AeMdw.Contract do
   @typep tx :: Node.tx()
   @typep block_hash :: <<_::256>>
 
-  @aex9_transfer_event_hash <<34, 60, 57, 226, 157, 255, 100, 103, 254, 221, 160, 151, 88, 217,
-                              23, 129, 197, 55, 46, 9, 31, 248, 107, 58, 249, 227, 16, 227, 134,
-                              86, 43, 239>>
-
   ################################################################################
   @spec encode(atom(), binary()) :: String.t()
   defdelegate encode(type, val), to: :aeser_api_encoder
@@ -136,18 +129,19 @@ defmodule AeMdw.Contract do
     }
   end
 
+  @metadata_type {:variant, [tuple: [], tuple: [], tuple: [], tuple: []]}
+  @option_string {:variant, [tuple: [], tuple: [:string]]}
+
   @spec aex141_signatures() :: map()
   def aex141_signatures() do
     %{
       "aex141_extensions" => {[], {:list, :string}},
       "meta_info" =>
-        {[], {:tuple, [:string, :string, {:variant, [tuple: [], tuple: [:string]]}, :atom]}},
-      "metadata" =>
-        {[:integer], {:variant, [tuple: [:string], tuple: [{:map, :string, :string}]]}},
-      "mint" => {[:address, {:variant, [tuple: [], tuple: [:string]]}], :integer},
+        {[],
+         {:tuple, [:string, :string, {:variant, [tuple: [], tuple: [:string]]}, @metadata_type]}},
       "balance" => {[:address], {:variant, [tuple: [], tuple: [:integer]]}},
       "owner" => {[:integer], {:variant, [tuple: [], tuple: [:address]]}},
-      "transfer" => {[:address, :address, :integer], {:tuple, []}},
+      "transfer" => {[:address, :address, :integer, @option_string], {:tuple, []}},
       "approve" => {[:address, :integer, :boolean], {:tuple, []}},
       "approve_all" => {[:address, :boolean], {:tuple, []}},
       "get_approved" => {[:integer], {:variant, [tuple: [], tuple: [:address]]}},
@@ -172,83 +166,6 @@ defmodule AeMdw.Contract do
   def is_success_ct_call?(%{result: %{abort: _error}}), do: false
   def is_success_ct_call?(_result_ok), do: true
 
-  @spec is_non_stateful_aex9_function?(method_name()) :: boolean()
-  def is_non_stateful_aex9_function?(<<method_name::binary>>) do
-    method_name in [
-      "aex9_extensions",
-      "meta_info",
-      "total_supply",
-      "owner",
-      "balance",
-      "balances"
-    ]
-  end
-
-  @spec get_aex9_transfer(DBN.pubkey(), String.t(), term()) ::
-          {DBN.pubkey(), DBN.pubkey(), non_neg_integer()} | nil
-  def get_aex9_transfer(from_pk, "transfer", [
-        %{type: :address, value: to_account_id},
-        %{type: :int, value: value}
-      ]),
-      do: {from_pk, Validate.id!(to_account_id), value}
-
-  def get_aex9_transfer(_caller_pk, "transfer_allowance", [
-        %{type: :address, value: from_account_id},
-        %{type: :address, value: to_account_id},
-        %{type: :int, value: value}
-      ]),
-      do: {Validate.id!(from_account_id), Validate.id!(to_account_id), value}
-
-  def get_aex9_transfer(_caller_pk, _other_function, _other_args), do: nil
-
-  @spec is_aex9?(DBN.pubkey() | type_info()) :: boolean()
-  def is_aex9?(pubkey) when is_binary(pubkey) do
-    case get_info(pubkey) do
-      {:ok, {type_info, _compiler_vsn, _source_hash}} -> is_aex9?(type_info)
-      {:error, _reason} -> false
-    end
-  end
-
-  def is_aex9?({:fcode, functions, _hash_names, _code}) do
-    AeMdw.Node.aex9_signatures()
-    |> has_all_signatures?(functions)
-  end
-
-  # AEVM
-  def is_aex9?(_no_fcode), do: false
-
-  def is_aex141?({:fcode, functions, _hash_names, _code}) do
-    AeMdw.Node.aex141_signatures()
-    |> has_all_signatures?(functions)
-  end
-
-  # AEVM
-  def is_aex141?(_no_fcode), do: false
-
-  # value of :aec_hash.blake2b_256_hash("Transfer")
-  @spec aex9_transfer_event_hash() :: event_hash()
-  def aex9_transfer_event_hash(), do: @aex9_transfer_event_hash
-
-  @spec aex9_meta_info(DBN.pubkey()) :: {:ok, aex9_meta_info()} | :not_found
-  def aex9_meta_info(contract_pk),
-    do: aex9_meta_info(contract_pk, DBN.top_height_hash(false))
-
-  def aex9_meta_info(contract_pk, {type, height, hash}) do
-    case call_contract(contract_pk, {type, height, hash}, "meta_info", []) do
-      {:ok, {:tuple, {name, symbol, decimals}}} ->
-        {:ok, {name, symbol, decimals}}
-
-      {:error, _call_error} ->
-        Log.info(
-          "aex9_meta_info not available for #{
-            :aeser_api_encoder.encode(:contract_pubkey, contract_pk)
-          }"
-        )
-
-        :not_found
-    end
-  end
-
   @spec call_contract(DBN.pubkey(), String.t(), list()) ::
           {:ok, call_result()} | {:error, any()} | :revert
   def call_contract(contract_pk, function_name, args),
@@ -427,12 +344,6 @@ defmodule AeMdw.Contract do
   #
   # Private functions
   #
-  defp has_all_signatures?(aexn_signatures, functions) do
-    Enum.all?(aexn_signatures, fn {hash, type} ->
-      match?({_code, ^type, _body}, Map.get(functions, hash))
-    end)
-  end
-
   # encoding and decoding vm data
   defp fate_val({:address, x}, f), do: f.({:address, encode(:account_pubkey, x)})
   defp fate_val({:oracle, x}, f), do: f.({:oracle, encode(:oracle_pubkey, x)})

lib/ae_mdw/contracts/aexn_contract.ex

@@ -0,0 +1,126 @@
+defmodule AeMdw.Contracts.AexnContract do
+  @moduledoc """
+  AEX-N detection and common calls to interact with the contract.
+  """
+
+  import AeMdwWeb.Helpers.AexnHelper, only: [enc_ct: 1]
+
+  alias AeMdw.Contract
+  alias AeMdw.Db.Model
+  alias AeMdw.Node.Db, as: NodeDb
+  alias AeMdw.Log
+
+  @typep pubkey :: NodeDb.pubkey()
+
+  @spec is_aex9?(pubkey() | Contract.type_info()) :: boolean()
+  def is_aex9?(pubkey) when is_binary(pubkey) do
+    case Contract.get_info(pubkey) do
+      {:ok, {type_info, _compiler_vsn, _source_hash}} -> is_aex9?(type_info)
+      {:error, _reason} -> false
+    end
+  end
+
+  def is_aex9?({:fcode, functions, _hash_names, _code}) do
+    AeMdw.Node.aex9_signatures()
+    |> has_all_signatures?(functions)
+  end
+
+  def is_aex9?(_no_fcode), do: false
+
+  @spec is_aex141?(pubkey()) :: boolean()
+  def is_aex141?(pubkey) when is_binary(pubkey) do
+    with {:ok, {type_info, _compiler_vsn, _source_hash}} <- Contract.get_info(pubkey),
+         true <- has_all_aex141_signatures?(type_info),
+         {:ok, extensions} <- call_contract(pubkey, "extensions") do
+      has_valid_aex141_extensions?(extensions, type_info)
+    else
+      _error_or_false ->
+        false
+    end
+  end
+
+  def is_aex141?(_no_fcode), do: false
+
+  @spec call_meta_info(pubkey()) :: {:ok, Model.aexn_meta_info()} | :not_found
+  def call_meta_info(contract_pk) do
+    with {:ok, {:tuple, meta_info_tuple}} <- call_contract(contract_pk, "meta_info", []) do
+      {:ok, meta_info_tuple}
+    end
+  end
+
+  #
+  # Private functions
+  #
+  defp call_contract(contract_pk, method, args \\ []) do
+    top_hash = NodeDb.top_height_hash(false)
+
+    case Contract.call_contract(contract_pk, top_hash, method, args) do
+      {:ok, return} ->
+        {:ok, return}
+
+      {:error, _call_error} ->
+        Log.warn("#{method} call error for #{enc_ct(contract_pk)}")
+        :not_found
+    end
+  end
+
+  defp has_all_signatures?(aexn_signatures, functions) do
+    Enum.all?(aexn_signatures, fn {hash, type} ->
+      match?({_code, ^type, _body}, Map.get(functions, hash))
+    end)
+  end
+
+  defp has_all_aex141_signatures?({:fcode, functions, _hash_names, _code}) do
+    valid_base_signatures? =
+      AeMdw.Node.aex141_signatures()
+      |> has_all_signatures?(functions)
+
+    valid_base_signatures? and valid_aex141_metadata?(functions)
+  end
+
+  defp has_all_aex141_signatures?(_no_fcode), do: false
+
+  @option_string {:variant, [tuple: [], tuple: [:string]]}
+  @option_metadata_map {:variant, [tuple: [], tuple: [{:map, :string, :string}]]}
+  @metadata_hash <<99, 148, 233, 122>>
+  @mint_hash <<207, 221, 154, 162>>
+  @burn_hash <<177, 239, 193, 123>>
+  @swap_hash <<17, 0, 79, 166>>
+  @check_swap_hash <<214, 57, 13, 126>>
+  @swapped_hash <<29, 236, 102, 255>>
+
+  defp valid_aex141_metadata?(functions) do
+    case Map.get(functions, @metadata_hash) do
+      nil ->
+        false
+
+      {_code, type, _body} ->
+        type == {[:integer], @option_string} or type == {[:integer], @option_metadata_map}
+    end
+  end
+
+  defp has_valid_aex141_extensions?(extensions, {:fcode, functions, _hash_names, _code}) do
+    Enum.all?(extensions, &valid_aex141_extension?(&1, functions))
+  end
+
+  defp valid_aex141_extension?("mintable", functions) do
+    case Map.get(functions, @mint_hash) do
+      nil ->
+        false
+
+      {_code, type, _body} ->
+        type == {[:address, @option_string], :integer} or
+          type == {[:address, @option_metadata_map], :integer}
+    end
+  end
+
+  defp valid_aex141_extension?("burnable", functions) do
+    match?({_code, {[:integer], {:tuple, []}}, _body}, functions[@burn_hash])
+  end
+
+  defp valid_aex141_extension?("swappable", functions) do
+    match?({_code, {[], {:tuple, []}}, _body}, functions[@swap_hash]) and
+      match?({_code, {[:address], :integer}, _body}, functions[@check_swap_hash]) and
+      match?({_code, {[], {:map, :address, :string}}, _body}, functions[@swapped_hash])
+  end
+end

lib/ae_mdw/db/contract.ex

@@ -4,6 +4,7 @@ defmodule AeMdw.Db.Contract do
   """
   alias AeMdw.Collection
   alias AeMdw.Contract
+  alias AeMdw.Contracts.AexnContract
   alias AeMdw.Database
   alias AeMdw.Db.Model
   alias AeMdw.Db.Origin
@@ -29,16 +30,25 @@ defmodule AeMdw.Db.Contract do
   @typep block_index :: AeMdw.Blocks.block_index()
   @typep txi :: AeMdw.Txs.txi()
 
-  @spec aex9_creation_write(state(), Contract.aex9_meta_info(), pubkey(), integer()) :: state()
-  def aex9_creation_write(state, {name, symbol, decimals}, contract_pk, txi) do
-    m_contract_name = Model.aexn_contract_name(index: {:aex9, name, contract_pk})
-    m_contract_sym = Model.aexn_contract_symbol(index: {:aex9, symbol, contract_pk})
+  @spec aexn_creation_write(
+          state(),
+          Model.aexn_type(),
+          Model.aexn_meta_info(),
+          pubkey(),
+          integer()
+        ) :: state()
+  def aexn_creation_write(state, aexn_type, aexn_meta_info, contract_pk, txi) do
+    name = elem(aexn_meta_info, 0)
+    symbol = elem(aexn_meta_info, 1)
+
+    m_contract_name = Model.aexn_contract_name(index: {aexn_type, name, contract_pk})
+    m_contract_sym = Model.aexn_contract_symbol(index: {aexn_type, symbol, contract_pk})
 
     m_contract_pk =
       Model.aexn_contract(
-        index: {:aex9, contract_pk},
+        index: {aexn_type, contract_pk},
         txi: txi,
-        meta_info: {name, symbol, decimals}
+        meta_info: aexn_meta_info
       )
 
     state
@@ -236,11 +246,11 @@ defmodule AeMdw.Db.Contract do
 
   @spec which_aexn_contract_pubkey(pubkey(), pubkey()) :: pubkey() | nil
   def which_aexn_contract_pubkey(contract_pk, addr) do
-    if Contract.is_aex9?(contract_pk) do
+    if AexnContract.is_aex9?(contract_pk) do
       contract_pk
     else
       # remotely called contract is aex9?
-      if addr != contract_pk and Contract.is_aex9?(addr), do: addr
+      if addr != contract_pk and AexnContract.is_aex9?(addr), do: addr
     end
   end
 
@@ -346,11 +356,11 @@ defmodule AeMdw.Db.Contract do
 
   @spec update_aex9_state(State.t(), pubkey(), block_index(), txi()) :: State.t()
   def update_aex9_state(state, contract_pk, {kbi, mbi} = block_index, txi) do
-    if Contract.is_aex9?(contract_pk) do
+    if AexnContract.is_aex9?(contract_pk) do
       with false <- State.exists?(state, Model.AexnContract, {:aex9, contract_pk}),
-           {:ok, aex9_meta_info} <- Contract.aex9_meta_info(contract_pk) do
+           {:ok, aex9_meta_info} <- AexnContract.call_meta_info(contract_pk) do
         AsyncTasks.Producer.enqueue(:derive_aex9_presence, [contract_pk, kbi, mbi, txi])
-        aex9_creation_write(state, aex9_meta_info, contract_pk, txi)
+        aexn_creation_write(state, :aex9, aex9_meta_info, contract_pk, txi)
       else
         true ->
           AsyncTasks.Producer.enqueue(:update_aex9_state, [contract_pk], [block_index, txi])

lib/ae_mdw/db/model.ex

@@ -302,12 +302,16 @@ defmodule AeMdw.Db.Model do
   #     index: {type, pubkey} where type = :aex9, :aex141, ...
   #     txi: txi
   #     meta_info: {name, symbol, decimals} | {name, symbol, base_url, metadata_type}
-  @type aexn_meta_info ::
-          {String.t(), String.t(), non_neg_integer()}
-          | {String.t(), String.t(), String.t(), atom()}
+  @type aexn_type :: :aex9 | :aex141
+  @type aexn_name :: String.t()
+  @type aexn_symbol :: String.t()
+  @type aex9_meta_info :: {aexn_name(), aexn_symbol(), non_neg_integer()}
+  @type aex141_meta_info :: {aexn_name(), aexn_symbol(), String.t(), atom()}
+  @type aexn_meta_info :: aex9_meta_info() | aex141_meta_info()
+
   @type aexn_contract ::
           record(:aexn_contract,
-            index: {:aex9 | :aex141, Db.pubkey()},
+            index: {aexn_type(), Db.pubkey()},
             txi: Txs.txi(),
             meta_info: aexn_meta_info()
           )