feat : transaction.merge endpoint

apps/omg_utils/lib/omg_utils/http_rpc/validators/base.ex

@@ -26,6 +26,7 @@ defmodule OMG.Utils.HttpRPC.Validator.Base do
   # IMPORTANT: Alias can use already defined validators, not other aliases (no backtracking)
   @aliases %{
     address: [:hex, length: 20],
+    currency: [:hex, length: 20],
     hash: [:hex, length: 32],
     signature: [:hex, length: 65],
     pos_integer: [:integer, greater: 0],
@@ -139,6 +140,11 @@ defmodule OMG.Utils.HttpRPC.Validator.Base do
   def max_length({list, []}, len) when is_list(list) and length(list) <= len, do: {list, []}
   def max_length({val, []}, len), do: {val, max_length: len}
 
+  @spec min_length({any(), list()}, non_neg_integer()) :: {any(), list()}
+  def min_length({_, [_ | _]} = err, _len), do: err
+  def min_length({list, []}, len) when is_list(list) and length(list) >= len, do: {list, []}
+  def min_length({val, []}, len), do: {val, min_length: len}
+
   @spec greater({any(), list()}, integer()) :: {any(), list()}
   def greater({_, [_ | _]} = err, _b), do: err
   def greater({val, []}, bound) when is_integer(val) and val > bound, do: {val, []}

apps/omg_utils/test/omg_utils/http_rpc/validators/base_test.exs

@@ -47,7 +47,8 @@ defmodule OMG.Utils.HttpRPC.Validator.BaseTest do
     "too_short_hash" => "0x" <> String.duplicate("00", 31),
     "len_1" => "1",
     "len_2" => <<1, 2, 3, 4, 5>>,
-    "max_len_1" => [1, 2, 3, 4, 5]
+    "max_len_1" => [1, 2, 3, 4, 5],
+    "min_len_1" => [1, 2, 3]
   }
 
   describe "Basic validation:" do
@@ -121,6 +122,16 @@ defmodule OMG.Utils.HttpRPC.Validator.BaseTest do
       assert {:error, {:validation_error, "max_len_1", {:max_length, 3}}} == expect(@params, "max_len_1", max_length: 3)
     end
 
+    test "min_length: positive cases" do
+      assert {:ok, [1, 2, 3]} == expect(@params, "min_len_1", min_length: 0)
+      assert {:ok, [1, 2, 3]} == expect(@params, "min_len_1", min_length: 2)
+      assert {:ok, [1, 2, 3]} == expect(@params, "min_len_1", min_length: 3)
+    end
+
+    test "min_length: negative cases" do
+      assert {:error, {:validation_error, "min_len_1", {:min_length, 4}}} == expect(@params, "min_len_1", min_length: 4)
+    end
+
     test "list: positive cases" do
       list = [1, "a", :b]
       assert {:ok, list} == expect(%{"list" => list}, "list", :list)

apps/omg_watcher_info/lib/omg_watcher_info/api/transaction.ex

@@ -92,7 +92,7 @@ defmodule OMG.WatcherInfo.API.Transaction do
   def create(order) do
     owner_inputs =
       order.owner
-      |> DB.TxOutput.get_sorted_grouped_utxos()
+      |> DB.TxOutput.get_sorted_grouped_utxos(:desc)
       |> TransactionCreator.select_inputs(order)
 
     case owner_inputs do
@@ -106,6 +106,42 @@ defmodule OMG.WatcherInfo.API.Transaction do
     end
   end
 
+  @doc """
+  Converts parameter keyword list to a map before passing it to multi-clause "handle_merge/`1"
+  """
+  @spec merge(Keyword.t()) :: create_t()
+  def merge(parameters) do
+    parameters |> Map.new() |> handle_merge()
+  end
+
+  @spec handle_merge(map()) :: create_t()
+  defp handle_merge(%{address: address, currency: currency}) do
+    merge_inputs =
+      address
+      |> DB.TxOutput.get_sorted_grouped_utxos(:asc)
+      |> Map.get(currency, [])
+
+    case merge_inputs do
+      [] ->
+        {:error, :no_inputs_found}
+
+      [_single_input] ->
+        {:error, :single_input}
+
+      inputs ->
+        {:ok, TransactionCreator.generate_merge_transactions(inputs)}
+    end
+  end
+
+  defp handle_merge(%{utxo_positions: utxo_positions}) do
+    with {:ok, inputs} <- get_merge_inputs(utxo_positions),
+         :ok <- no_duplicates(inputs),
+         :ok <- single_owner(inputs),
+         :ok <- single_currency(inputs) do
+      {:ok, TransactionCreator.generate_merge_transactions(inputs)}
+    end
+  end
+
   defp get_utxos_count(currencies) do
     Enum.reduce(currencies, 0, fn {_, currency_inputs}, acc -> acc + length(currency_inputs) end)
   end
@@ -132,6 +168,43 @@ defmodule OMG.WatcherInfo.API.Transaction do
     |> respond(:complete)
   end
 
+  @spec get_merge_inputs(list()) :: {:ok, list()} | {:error, atom()}
+  defp get_merge_inputs(utxo_positions) do
+    Enum.reduce_while(utxo_positions, {:ok, []}, fn encoded_position, {:ok, acc} ->
+      case encoded_position |> Utxo.Position.decode!() |> DB.TxOutput.get_by_position() do
+        nil -> {:halt, {:error, :position_not_found}}
+        input -> {:cont, {:ok, [input | acc]}}
+      end
+    end)
+  end
+
+  @spec no_duplicates(list()) :: :ok | {:error, :duplicate_input_positions}
+  defp no_duplicates(inputs) do
+    inputs
+    |> Enum.uniq()
+    |> length()
+    |> case do
+      n when n == length(inputs) -> :ok
+      _ -> {:error, :duplicate_input_positions}
+    end
+  end
+
+  @spec single_owner(list()) :: :ok | {:error, :multiple_input_owners}
+  defp single_owner(inputs) do
+    case inputs |> Enum.uniq_by(fn input -> input.owner end) |> length() do
+      1 -> :ok
+      _ -> {:error, :multiple_input_owners}
+    end
+  end
+
+  @spec single_currency(list()) :: :ok | {:error, :multiple_currencies}
+  defp single_currency(inputs) do
+    case inputs |> Enum.uniq_by(fn input -> input.currency end) |> length() do
+      1 -> :ok
+      _ -> {:error, :multiple_currencies}
+    end
+  end
+
   defp respond({:ok, transactions}, result), do: {:ok, %{result: result, transactions: transactions}}
   defp respond(error, _), do: error
 end

apps/omg_watcher_info/lib/omg_watcher_info/db/txoutput.ex

@@ -43,6 +43,8 @@ defmodule OMG.WatcherInfo.DB.TxOutput do
           sigs: binary()
         }
 
+  @type order_t() :: :asc | :desc
+
   @primary_key false
   schema "txoutputs" do
     field(:blknum, :integer, primary_key: true)
@@ -209,14 +211,14 @@ defmodule OMG.WatcherInfo.DB.TxOutput do
     end)
   end
 
-  @spec get_sorted_grouped_utxos(OMG.Crypto.address_t()) :: %{OMG.Crypto.address_t() => list(%__MODULE__{})}
-  def get_sorted_grouped_utxos(owner) do
+  @spec get_sorted_grouped_utxos(OMG.Crypto.address_t(), order_t()) :: %{OMG.Crypto.address_t() => list(%__MODULE__{})}
+  def get_sorted_grouped_utxos(owner, order) do
     # TODO: use clever DB query to get following out of DB
     owner
     |> get_all_utxos()
     |> Enum.group_by(fn utxo -> utxo.currency end)
     |> Enum.map(fn {currency, utxos} ->
-      {currency, Enum.sort_by(utxos, fn utxo -> utxo.amount end, :desc)}
+      {currency, Enum.sort_by(utxos, fn utxo -> utxo.amount end, order)}
     end)
     |> Map.new()
   end

apps/omg_watcher_info/lib/omg_watcher_info/transaction.ex

@@ -76,6 +76,7 @@ defmodule OMG.WatcherInfo.Transaction do
         }
 
   @type utxos_map_t() :: %{UtxoSelection.currency_t() => UtxoSelection.utxo_list_t()}
+
   @type inputs_t() :: {:ok, utxos_map_t()} | {:error, {:insufficient_funds, list(map())}}
 
   @doc """
@@ -154,6 +155,13 @@ defmodule OMG.WatcherInfo.Transaction do
     }
   end
 
+  def include_typed_data({:ok, txs}) do
+    {
+      :ok,
+      %{transactions: Enum.map(txs, fn tx -> Map.put_new(tx, :typed_data, add_type_specs(tx)) end)}
+    }
+  end
+
   @spec generate_merge_transactions(UtxoSelection.utxo_list_t()) :: list(transaction_t())
   def generate_merge_transactions(merge_inputs) do
     merge_inputs

apps/omg_watcher_info/test/omg_watcher_info/api/transaction_test.exs

@@ -0,0 +1,191 @@
+# Copyright 2019-2020 OmiseGO Pte Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+defmodule OMG.WatcherInfo.API.TransactionTest do
+  use ExUnitFixtures
+  use ExUnit.Case, async: false
+  use OMG.WatcherInfo.Fixtures
+
+  alias OMG.Utxo.Position
+  alias OMG.WatcherInfo.API.Transaction
+
+  import OMG.WatcherInfo.Factory
+
+  @alice <<1::160>>
+  @bob <<2::160>>
+  @currency_1 <<3::160>>
+  @currency_2 <<4::160>>
+
+  describe "merge/1 with address and currency parameters" do
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "merge with address and currency forms multiple merge transactions if possible" do
+      insert_initial_utxo()
+
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+
+      assert {:ok, [%{inputs: [_, _, _, _], outputs: [output_1]}, %{inputs: [_, _, _], outputs: [output_2]}]} =
+               Transaction.merge(%{address: @alice, currency: @currency_1})
+
+      assert output_1 === %{amount: 4, currency: @currency_1, owner: @alice}
+      assert output_2 === %{amount: 3, currency: @currency_1, owner: @alice}
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "fetches inputs for the given addresss only" do
+      insert_initial_utxo()
+
+      _ = insert(:txoutput, currency: @currency_1, owner: @bob, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @bob, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+
+      assert {:ok, [alice_merge]} = Transaction.merge(%{address: @alice, currency: @currency_1})
+      assert %{inputs: [_, _, _, _], outputs: [%{amount: 4, currency: @currency_1, owner: @alice}]} = alice_merge
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "fetches inputs for the given currency only" do
+      insert_initial_utxo()
+
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_2, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_2, owner: @alice, amount: 1)
+
+      assert {:ok, [alice_merge]} = Transaction.merge(%{address: @alice, currency: @currency_2})
+      assert %{inputs: [_, _], outputs: [%{amount: 2, currency: @currency_2, owner: @alice}]} = alice_merge
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns one merge transaction if five UTXOs are available – prioritising the lowest value inputs" do
+      insert_initial_utxo()
+
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 2)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 3)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 4)
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 5)
+
+      assert {:ok, [merge_tx]} = Transaction.merge(%{address: @alice, currency: @currency_1})
+
+      assert %{
+               inputs: [%{amount: 1}, %{amount: 2}, %{amount: 3}, %{amount: 4}],
+               outputs: [%{amount: 10, currency: @currency_1, owner: @alice}]
+             } = merge_tx
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "merge with address and currency fails on single input" do
+      insert_initial_utxo()
+
+      _ = insert(:txoutput, currency: @currency_1, owner: @alice, amount: 1)
+      _ = insert(:txoutput, currency: @currency_2, owner: @alice, amount: 1)
+
+      assert Transaction.merge(%{address: @alice, currency: @currency_1}) ==
+               {:error, :single_input}
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns expected error when no inputs are found" do
+      assert Transaction.merge(%{address: @alice, currency: @currency_1}) == {:error, :no_inputs_found}
+    end
+  end
+
+  describe "merge/1 with utxo_positions parameter" do
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "given  valid `utxo_positions` parameters, forms a merge transaction correctly" do
+      insert_initial_utxo()
+
+      position_1 =
+        :txoutput |> insert(owner: @alice, currency: @currency_1, amount: 1) |> encoded_position_from_insert()
+
+      position_2 =
+        :txoutput |> insert(owner: @alice, currency: @currency_1, amount: 1) |> encoded_position_from_insert()
+
+      position_3 =
+        :txoutput |> insert(owner: @alice, currency: @currency_1, amount: 1) |> encoded_position_from_insert()
+
+      {:ok, [%{inputs: inputs, outputs: outputs}]} =
+        Transaction.merge([{:utxo_positions, [position_1, position_2, position_3]}])
+
+      assert length(inputs) == 3
+      assert [%{amount: 3, currency: @currency_1, owner: @alice}] = outputs
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns an error if any duplicate positions are in the list" do
+      insert_initial_utxo()
+
+      position_1 = :txoutput |> insert() |> encoded_position_from_insert()
+
+      assert Transaction.merge([{:utxo_positions, [position_1, position_1]}]) ==
+               {:error, :duplicate_input_positions}
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns expected error if any position is not found" do
+      insert_initial_utxo()
+
+      position_1 = :txoutput |> insert() |> encoded_position_from_insert()
+      position_2 = :txoutput |> insert() |> encoded_position_from_insert()
+      position_3 = :txoutput |> insert() |> encoded_position_from_insert()
+
+      empty_position = insert(:txoutput) |> Map.update!(:blknum, fn n -> n + 1 end) |> encoded_position_from_insert()
+
+      assert Transaction.merge([{:utxo_positions, [position_1, position_2, position_3, empty_position]}]) ==
+               {:error, :position_not_found}
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns an error if there is more than one owner for the given set of UTXO positions" do
+      insert_initial_utxo()
+
+      position_1 = :txoutput |> insert(owner: @alice, currency: @currency_1) |> encoded_position_from_insert()
+      position_2 = :txoutput |> insert(owner: @alice, currency: @currency_1) |> encoded_position_from_insert()
+      position_3 = :txoutput |> insert(owner: @bob, currency: @currency_1) |> encoded_position_from_insert()
+
+      assert Transaction.merge([{:utxo_positions, [position_1, position_2, position_3]}]) ==
+               {:error, :multiple_input_owners}
+    end
+
+    @tag fixtures: [:phoenix_ecto_sandbox]
+    test "returns an error if there is more than one currency for the given set of UTXO positions" do
+      insert_initial_utxo()
+
+      position_1 = :txoutput |> insert(owner: @alice, currency: @currency_1) |> encoded_position_from_insert()
+      position_2 = :txoutput |> insert(owner: @alice, currency: @currency_1) |> encoded_position_from_insert()
+      position_3 = :txoutput |> insert(owner: @alice, currency: @currency_2) |> encoded_position_from_insert()
+
+      assert Transaction.merge([{:utxo_positions, [position_1, position_2, position_3]}]) ==
+               {:error, :multiple_currencies}
+    end
+  end
+
+  defp encoded_position_from_insert(%{oindex: oindex, txindex: txindex, blknum: blknum}) do
+    Position.encode({:utxo_position, blknum, txindex, oindex})
+  end
+
+  # This is needed so that UTXOs inserted subsequently can have a proper (non-zero) position
+  defp insert_initial_utxo() do
+    insert(:txoutput)
+  end
+end