chore: remove all consistency credo warnings (#1490)

Author: sborrazas

lib/ae_mdw/contract.ex

@@ -34,7 +34,10 @@ defmodule AeMdw.Contract do
   # for balances or balance
   @type serialized_call :: map()
   # fcode or aevm info
-  @type type_info :: {:fcode, map(), map(), map()} | list()
+  @type fhash() :: binary()
+  @type is_payable() :: boolean()
+  @type type_info ::
+          {:fcode, map(), map(), map()} | [{fhash(), fname(), is_payable(), binary(), binary()}]
   @type compiler_vsn :: String.t()
   @type source_hash :: <<_::256>>
   @type ct_info :: {type_info(), compiler_vsn(), source_hash()}
@@ -160,7 +163,7 @@ defmodule AeMdw.Contract do
   defp decode_call_data(contract, call_data),
     do: decode_call_data(contract, call_data, &id/1)
 
-  defp decode_call_data({:fcode, _, _, _} = fate_info, call_data, mapper) do
+  defp decode_call_data({:fcode, _funs, _syms, _annotations} = fate_info, call_data, mapper) do
     {:tuple, {fun_hash, {:tuple, tup_args}}} = :aeb_fate_encoding.deserialize(call_data)
 
     # sample fun_hash not matching: <<74, 202, 20, 78, 108, 15, 83, 141, 70, 92, 69, 235, 191, 127, 43, 123, 21, 80, 189, 1, 86, 76, 125, 166, 246, 81, 67, 150, 69, 95, 156, 6>>
@@ -176,26 +179,38 @@ defmodule AeMdw.Contract do
   defp decode_call_data([_ | _] = aevm_info, call_data, mapper) do
     {:ok, fun_hash} = :aeb_aevm_abi.get_function_hash_from_calldata(call_data)
     {:ok, fun_name} = :aeb_aevm_abi.function_name_from_type_hash(fun_hash, aevm_info)
-    {:ok, arg_type, _} = :aeb_aevm_abi.typereps_from_type_hash(fun_hash, aevm_info)
-    {:ok, {_, vm_args}} = :aeb_heap.from_binary({:tuple, [:word, arg_type]}, call_data)
+    {:ok, arg_type, _type_rep} = :aeb_aevm_abi.typereps_from_type_hash(fun_hash, aevm_info)
+    {:ok, {_arg_type, vm_args}} = :aeb_heap.from_binary({:tuple, [:word, arg_type]}, call_data)
     {fun_name, aevm_val({arg_type, vm_args}, mapper)}
   end
 
   defp decode_call_result(_info, _fun_name, :error, value, mapper),
     do: mapper.(%{error: [value]})
 
-  defp decode_call_result({:fcode, _, _, _}, _fun_name, :revert, value, mapper),
-    do: mapper.(%{abort: [:aeb_fate_encoding.deserialize(value)]})
+  defp decode_call_result(
+         {:fcode, _functions, _symbols, _annotations},
+         _fun_name,
+         :revert,
+         value,
+         mapper
+       ),
+       do: mapper.(%{abort: [:aeb_fate_encoding.deserialize(value)]})
 
-  defp decode_call_result([_ | _], _fun_name, :revert, value, mapper),
+  defp decode_call_result([_arg_type, _ret_type], _fun_name, :revert, value, mapper),
     do: mapper.(%{abort: [ok!(:aeb_heap.from_binary(:string, value))]})
 
-  defp decode_call_result({:fcode, _, _, _}, _fun_name, :ok, value, mapper),
-    do: fate_val(:aeb_fate_encoding.deserialize(value), mapper)
+  defp decode_call_result(
+         {:fcode, _functions, _symbols, _annotations},
+         _fun_name,
+         :ok,
+         value,
+         mapper
+       ),
+       do: fate_val(:aeb_fate_encoding.deserialize(value), mapper)
 
-  defp decode_call_result([_ | _] = info, fun_name, :ok, value, mapper) do
+  defp decode_call_result([_arg_type | _ret_type] = info, fun_name, :ok, value, mapper) do
     {:ok, hash} = :aeb_aevm_abi.type_hash_from_function_name(fun_name, info)
-    {:ok, _, res_type} = :aeb_aevm_abi.typereps_from_type_hash(hash, info)
+    {:ok, _type_rep, res_type} = :aeb_aevm_abi.typereps_from_type_hash(hash, info)
     {:ok, vm_res} = :aeb_heap.from_binary(res_type, value)
     aevm_val({res_type, vm_res}, mapper)
   end
@@ -365,7 +380,7 @@ defmodule AeMdw.Contract do
   defp fate_val(x, f) when is_map(x),
     do: f.({:map, Enum.map(x, fn {k, v} -> %{key: fate_val(k, f), val: fate_val(v, f)} end)})
 
-  defp fate_val({:variant, _, tag, args}, f),
+  defp fate_val({:variant, _bytecode, tag, args}, f),
     do: f.({:variant, [tag | Enum.map(tuple_to_list(args), &fate_val(&1, f))]})
 
   defp aevm_val({:word, x}, f) when is_integer(x), do: f.({:word, x})
@@ -424,7 +439,7 @@ defmodule AeMdw.Contract do
       trees_in = consensus.state_pre_transform_micro_node(node, trees_in)
       env = :aetx_env.tx_env_from_key_header(prev_key_header, prev_key_hash, time, prev_hash)
 
-      {:ok, _, _, events} =
+      {:ok, _sigs, _trees, events} =
         :aec_block_micro_candidate.apply_block_txs_strict(txs_taken, trees_in, env)
 
       events

lib/ae_mdw/db/mutations/write_fields_mutation.ex

@@ -45,7 +45,7 @@ defmodule AeMdw.Db.WriteFieldsMutation do
     tx_type
     |> Node.tx_ids()
     |> Enum.reduce(state, fn {field, pos}, state ->
-      <<_::256>> = pk = resolve_pubkey(state, elem(tx, pos), tx_type, field, block_index)
+      <<_pk::256>> = pk = resolve_pubkey(state, elem(tx, pos), tx_type, field, block_index)
       field_pos = AeMdw.Fields.field_pos_mask(wrap_tx, pos)
       {tx_type, pos} = if wrap_tx, do: {wrap_tx, field_pos}, else: {tx_type, pos}
       write_field(state, tx_type, pos, pk, txi)

lib/ae_mdw/db/sync/id_counter.ex

@@ -9,13 +9,13 @@ defmodule AeMdw.Db.Sync.IdCounter do
   require Model
 
   @spec incr_count(State.t(), Model.id_count_index()) :: State.t()
-  def incr_count(state, {_, _, _} = field_key) do
+  def incr_count(state, {_tx_type, _pos, _pk} = field_key) do
     update_count(state, field_key, 1)
   end
 
   @spec update_count(State.t(), Model.id_count_index(), integer()) :: State.t()
-  def update_count(state, {_, _, _} = field_key, delta) do
-    case State.get(state, AeMdw.Db.Model.IdCount, field_key) do
+  def update_count(state, {_tx_type, _pos, _pk} = field_key, delta) do
+    case State.get(state, Model.IdCount, field_key) do
       :not_found ->
         model = Model.id_count(index: field_key, count: 0)
         write_count(state, model, 1)
@@ -31,6 +31,6 @@ defmodule AeMdw.Db.Sync.IdCounter do
   @spec write_count(State.t(), Model.id_count(), integer()) :: State.t()
   defp write_count(state, Model.id_count(count: total) = model, delta) do
     model = Model.id_count(model, count: total + delta)
-    State.put(state, AeMdw.Db.Model.IdCount, model)
+    State.put(state, Model.IdCount, model)
   end
 end

lib/ae_mdw/extract.ex

@@ -1,3 +1,4 @@
+# credo:disable-for-this-file Credo.Check.Consistency.UnusedVariableNames
 defmodule AeMdw.Extract do
   @moduledoc "currently we require that AE node is compiled with debug_info"
 

lib/ae_mdw/node/db.ex

@@ -129,22 +129,22 @@ defmodule AeMdw.Node.Db do
 
   @spec get_tx_data(binary()) ::
           {Blocks.block_hash(), Node.tx_type(), Node.signed_tx(), Node.tx()}
-  def get_tx_data(<<_::256>> = tx_hash) do
+  def get_tx_data(<<_pk::256>> = tx_hash) do
     {block_hash, signed_tx} = :aec_db.find_tx_with_location(tx_hash)
     {type, tx_rec} = :aetx.specialize_type(:aetx_sign.tx(signed_tx))
     {block_hash, type, signed_tx, tx_rec}
   end
 
   @spec get_tx(binary()) :: Node.tx()
-  def get_tx(<<_::256>> = tx_hash) do
-    {_, signed_tx} = :aec_db.find_tx_with_location(tx_hash)
-    {_, tx_rec} = :aetx.specialize_type(:aetx_sign.tx(signed_tx))
+  def get_tx(<<_pk::256>> = tx_hash) do
+    {_block_hash, signed_tx} = :aec_db.find_tx_with_location(tx_hash)
+    {_type, tx_rec} = :aetx.specialize_type(:aetx_sign.tx(signed_tx))
     tx_rec
   end
 
   @spec get_signed_tx(binary()) :: tuple()
-  def get_signed_tx(<<_::256>> = tx_hash) do
-    {_, signed_tx} = :aec_db.find_tx_with_location(tx_hash)
+  def get_signed_tx(<<_pk::256>> = tx_hash) do
+    {_block_hash, signed_tx} = :aec_db.find_tx_with_location(tx_hash)
     signed_tx
   end
 
@@ -158,7 +158,7 @@ defmodule AeMdw.Node.Db do
   def top_height_hash(true = _the_very_top?) do
     {type, header} =
       case :aec_chain.top_block() do
-        {:mic_block, header, _txs, _} -> {:micro, header}
+        {:mic_block, header, _txs, _pof} -> {:micro, header}
         {:key_block, header} -> {:key, header}
       end
 

lib/ae_mdw/validate.ex

@@ -4,27 +4,27 @@ defmodule AeMdw.Validate do
   alias :aeser_api_encoder, as: Enc
 
   # returns pubkey
-  def id(<<_::256>> = id),
+  def id(<<_pk::256>> = id),
     do: {:ok, id}
 
-  def id(<<_prefix::2-binary, "_", _::binary>> = id) do
+  def id(<<_prefix::2-binary, "_", _pk::binary>> = id) do
     try do
       {_id_type, pk} = Enc.decode(id)
       {:ok, pk}
     rescue
-      _ -> {:error, {ErrInput.Id, id}}
+      _error -> {:error, {ErrInput.Id, id}}
     end
   end
 
-  def id({:id, _, <<_::256>> = pk}),
+  def id({:id, _tag, <<_pk::256>> = pk}),
     do: {:ok, pk}
 
   def id(id),
     do: {:error, {ErrInput.Id, id}}
 
   def id!(id), do: unwrap!(&id/1, id)
 
-  def id(<<prefix::2-binary, "_", _::binary>> = ident, [_ | _] = allowed_types) do
+  def id(<<prefix::2-binary, "_", _pk::binary>> = ident, [_type1 | _rest_types] = allowed_types) do
     case prefix in AE.id_prefixes() do
       true ->
         case Enc.safe_decode({:id_hash, allowed_types}, ident) do
@@ -40,13 +40,13 @@ defmodule AeMdw.Validate do
     end
   end
 
-  def id({:id, hash_type, <<_::256>> = pk} = id, [_ | _] = allowed_types),
+  def id({:id, hash_type, <<_pk::256>> = pk} = id, [_type1 | _rest_types] = allowed_types),
     do: (AE.id_type(hash_type) in allowed_types && {:ok, pk}) || {:error, {ErrInput.Id, id}}
 
-  def id(<<_::256>> = pk, [_ | _] = _allowed_types),
+  def id(<<_pk::256>> = pk, [_type1 | _rest_types] = _allowed_types),
     do: {:ok, pk}
 
-  def id(id, _),
+  def id(id, _allowed_types),
     do: {:error, {ErrInput.Id, id}}
 
   def id!(id, allowed_types), do: unwrap!(&id(&1, allowed_types), id)
@@ -77,7 +77,7 @@ defmodule AeMdw.Validate do
           nil -> {:error, {ErrInput.NotFound, name_ident}}
         end
 
-      _ ->
+      _error ->
         ok? = is_binary(name_ident) and name_ident != "" and String.printable?(name_ident)
 
         case ok? do
@@ -141,7 +141,7 @@ defmodule AeMdw.Validate do
   def nonneg_int(s) when is_binary(s) do
     case Integer.parse(s, 10) do
       {i, ""} when i >= 0 -> {:ok, i}
-      _ -> {:error, {ErrInput.NonnegInt, s}}
+      _error_or_invalid -> {:error, {ErrInput.NonnegInt, s}}
     end
   end
 
@@ -155,7 +155,7 @@ defmodule AeMdw.Validate do
     map_nni = fn s, f ->
       case nonneg_int(s) do
         {:ok, i} -> f.(i)
-        _ -> {:error, {ErrInput.BlockIndex, x}}
+        _error -> {:error, {ErrInput.BlockIndex, x}}
       end
     end
 
@@ -165,14 +165,14 @@ defmodule AeMdw.Validate do
              {:ok, mbi} <- map_nni.(mbi, &{:ok, &1}) do
           {:ok, {kbi, mbi}}
         else
-          _ ->
+          _invalid ->
             {:error, {ErrInput.BlockIndex, x}}
         end
 
       [kbi | rem] when rem in [[], ["-1"]] ->
         map_nni.(kbi, &{:ok, {&1, -1}})
 
-      _ ->
+      _invalid ->
         {:error, {ErrInput.BlockIndex, x}}
     end
   end

lib/ae_mdw_web/benchmark/aggregator.ex

@@ -22,7 +22,7 @@ defmodule AeMdwWeb.Benchmark.Aggregator do
     end
   end
 
-  def extract_values([], _, acc), do: acc
+  def extract_values([], _key, acc), do: acc
 
   def extract_values([h | t], key, acc) do
     time = h[key].time

lib/ae_mdw_web/benchmark/bench.ex

@@ -90,8 +90,8 @@ defmodule Mix.Tasks.Bench do
     end)
   end
 
-  defp percentile([], _), do: nil
-  defp percentile([x], _), do: x
+  defp percentile([], _n), do: nil
+  defp percentile([x], _n), do: x
 
   defp percentile(list, n) when is_list(list) and is_number(n) do
     s = Enum.sort(list)
@@ -119,7 +119,7 @@ defmodule Mix.Tasks.Bench do
       200, acc ->
         %{acc | successful_requests: acc[:successful_requests] + 1}
 
-      _, acc ->
+      _status, acc ->
         %{acc | failed_requests: acc[:failed_requests] + 1}
     end)
   end

test/integration/ae_mdw_web/controllers/util_controller_test.exs

@@ -11,7 +11,7 @@ defmodule Integration.AeMdwWeb.UtilControllerTest do
     test "get middleware status", %{conn: conn} do
       state = State.new()
       {:ok, top_kb} = :aec_chain.top_key_block()
-      {_, _, node_vsn} = Application.started_applications() |> List.keyfind(:aecore, 0)
+      {_app, _desc, node_vsn} = Application.started_applications() |> List.keyfind(:aecore, 0)
       node_height = :aec_blocks.height(top_kb)
       {:ok, mdw_tx_index} = DbUtil.last_txi(state)