Resolve Message ReplicationError do not handle all error_762

lib/archethic/p2p/message.ex

@@ -466,8 +466,8 @@ defmodule Archethic.P2P.Message do
     <<232::8, encoded_transaction_summaries_len::binary, transaction_summaries_bin::bitstring>>
   end
 
-  def encode(%ReplicationError{address: address, reason: reason}) do
-    <<233::8, address::binary, ReplicationError.serialize_reason(reason)::8>>
+  def encode(msg = %ReplicationError{}) do
+    <<233::8, ReplicationError.serialize(msg)::bitstring>>
   end
 
   def encode(%ValidationError{context: :network_issue, reason: reason, address: address}) do
@@ -1018,15 +1018,7 @@ defmodule Archethic.P2P.Message do
   end
 
   def decode(<<233::8, rest::bitstring>>) do
-    {address, <<reason::8, rest::bitstring>>} = Utils.deserialize_address(rest)
-
-    {
-      %ReplicationError{
-        address: address,
-        reason: ReplicationError.deserialize_reason(reason)
-      },
-      rest
-    }
+    ReplicationError.deserialize(rest)
   end
 
   def decode(<<234::8, rest::bitstring>>) do

lib/archethic/p2p/message/replication_error.ex

@@ -4,49 +4,107 @@ defmodule Archethic.P2P.Message.ReplicationError do
   """
 
   alias Archethic.Replication.TransactionValidator
+  alias Archethic.Utils
 
   @enforce_keys [:address, :reason]
   defstruct [:address, :reason]
 
-  @type reason ::
-          TransactionValidator.error() | :transaction_already_exists
-
   @type t :: %__MODULE__{
           address: binary(),
           reason: reason()
         }
 
+  @type reason :: TransactionValidator.error() | :transaction_already_exists
+
   @doc """
-  Serialize an error reason
+  Serialize a replication error message
+
+        iex> %ReplicationError{
+        ...> address: << 0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234,
+        ...> 201, 172, 3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251>>,
+        ...> reason: :transaction_already_exists
+        ...>} |> ReplicationError.serialize()
+        << 0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234, 201, 172, 3,
+         195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251, 1>>
+
+        iex> %ReplicationError{
+        ...> address: << 0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234,
+        ...> 201, 172, 3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251>>,
+        ...> reason: :invalid_unspent_outputs
+        ...>} |> ReplicationError.serialize()
+        << 0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234, 201, 172, 3,
+         195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251, 14>>
+
   """
+  @spec serialize(%__MODULE__{}) :: <<_::32, _::_*8>>
+  def serialize(%__MODULE__{address: address, reason: reason}) do
+    <<address::binary, serialize_reason(reason)::8>>
+  end
+
   @spec serialize_reason(reason()) :: non_neg_integer()
-  def serialize_reason(:transaction_already_exists), do: 1
-  def serialize_reason(:invalid_atomic_commitment), do: 2
-  def serialize_reason(:invalid_node_election), do: 3
-  def serialize_reason(:invalid_proof_of_work), do: 4
-  def serialize_reason(:invalid_transaction_fee), do: 5
-  def serialize_reason(:invalid_transaction_movements), do: 6
-  def serialize_reason(:insufficient_funds), do: 7
-  def serialize_reason(:invalid_chain), do: 8
-  def serialize_reason(:invalid_transaction_with_inconsistencies), do: 9
-  def serialize_reason(:invalid_contract_acceptance), do: 10
-  def serialize_reason(:invalid_pending_transaction), do: 11
-  def serialize_reason(:invalid_inherit_constraints), do: 12
+  defp serialize_reason(:transaction_already_exists), do: 1
+  defp serialize_reason(:invalid_atomic_commitment), do: 2
+  defp serialize_reason(:invalid_node_election), do: 3
+  defp serialize_reason(:invalid_proof_of_work), do: 4
+  defp serialize_reason(:invalid_transaction_fee), do: 5
+  defp serialize_reason(:invalid_transaction_movements), do: 6
+  defp serialize_reason(:insufficient_funds), do: 7
+  defp serialize_reason(:invalid_chain), do: 8
+  defp serialize_reason(:invalid_transaction_with_inconsistencies), do: 9
+  defp serialize_reason(:invalid_contract_acceptance), do: 10
+  defp serialize_reason(:invalid_pending_transaction), do: 11
+  defp serialize_reason(:invalid_inherit_constraints), do: 12
+  defp serialize_reason(:invalid_validation_stamp_signature), do: 13
+  defp serialize_reason(:invalid_unspent_outputs), do: 14
 
   @doc """
-  Deserialize an error reason
+  DeSerialize a replication error message
+
+        iex> <<0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234, 201, 172,
+        ...>  3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251,  1>>
+        ...> |> ReplicationError.deserialize()
+        {
+        %ReplicationError{
+        address: <<0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14,187, 133,59, 234, 201, 172,
+        3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251>>,
+        reason: :transaction_already_exists
+        },""}
+
+
+        iex>  <<0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14, 187, 133, 59, 234, 201, 172,
+        ...>  3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31, 185, 73, 251, 14>>
+        ...> |> ReplicationError.deserialize()
+        {
+        %ReplicationError{
+        address: <<0, 0, 94, 5, 249, 103, 126, 31, 43, 57, 25, 14,187, 133, 59, 234, 201, 172,
+        3, 195, 43, 81, 81, 146, 164, 202, 147, 218, 207, 204, 31,185, 73, 251>>,
+        reason: :invalid_unspent_outputs
+        },""}
   """
-  @spec deserialize_reason(non_neg_integer()) :: reason()
-  def deserialize_reason(1), do: :transaction_already_exists
-  def deserialize_reason(2), do: :invalid_atomic_commitment
-  def deserialize_reason(3), do: :invalid_node_election
-  def deserialize_reason(4), do: :invalid_proof_of_work
-  def deserialize_reason(5), do: :invalid_transaction_fee
-  def deserialize_reason(6), do: :invalid_tranxaction_movements
-  def deserialize_reason(7), do: :insufficient_funds
-  def deserialize_reason(8), do: :invalid_chain
-  def deserialize_reason(9), do: :invalid_transaction_with_inconsistencies
-  def deserialize_reason(10), do: :invalid_contract_acceptance
-  def deserialize_reason(11), do: :invalid_pending_transaction
-  def deserialize_reason(12), do: :invalid_inherit_constraints
+  @spec deserialize(bin :: bitstring) :: {%__MODULE__{}, bitstring()}
+  def deserialize(bin) do
+    {address, rest} = Utils.deserialize_address(bin)
+    {reason, rest} = deserialize_reason(rest)
+
+    {%__MODULE__{address: address, reason: reason}, rest}
+  end
+
+  @spec deserialize_reason(bin :: bitstring) :: {atom, bitstring}
+  def deserialize_reason(<<nb::8, rest::bitstring>>), do: {error(nb), rest}
+
+  @spec error(1..255) :: atom
+  defp error(1), do: :transaction_already_exists
+  defp error(2), do: :invalid_atomic_commitment
+  defp error(3), do: :invalid_node_election
+  defp error(4), do: :invalid_proof_of_work
+  defp error(5), do: :invalid_transaction_fee
+  defp error(6), do: :invalid_transaction_movements
+  defp error(7), do: :insufficient_funds
+  defp error(8), do: :invalid_chain
+  defp error(9), do: :invalid_transaction_with_inconsistencies
+  defp error(10), do: :invalid_contract_acceptance
+  defp error(11), do: :invalid_pending_transaction
+  defp error(12), do: :invalid_inherit_constraints
+  defp error(13), do: :invalid_validation_stamp_signature
+  defp error(14), do: :invalid_unspent_outputs
 end

lib/archethic/replication/transaction_validator.ex

@@ -34,16 +34,16 @@ defmodule Archethic.Replication.TransactionValidator do
           :invalid_atomic_commitment
           | :invalid_node_election
           | :invalid_proof_of_work
-          | :invalid_validation_stamp_signature
           | :invalid_transaction_fee
           | :invalid_transaction_movements
           | :insufficient_funds
-          | :invalid_unspent_outputs
           | :invalid_chain
           | :invalid_transaction_with_inconsistencies
           | :invalid_contract_acceptance
           | :invalid_pending_transaction
           | :invalid_inherit_constraints
+          | :invalid_validation_stamp_signature
+          | :invalid_unspent_outputs
 
   @doc """
   Validate transaction with context

mix.exs

@@ -125,6 +125,7 @@ defmodule Archethic.MixProject do
         "clean",
         "format",
         "compile",
+        " hex.outdated --within-requirements",
         "credo",
         "sobelow",
         "cmd mix test --trace",