cabbage test for payment v2

apps/omg/lib/omg/state/transaction/payment/builder.ex

@@ -0,0 +1,78 @@
+# 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.State.Transaction.Payment.Builder do
+  @moduledoc """
+  Module to build payment tx of different tx types. (eg. v1 and v2)
+  """
+
+  alias OMG.Crypto
+  alias OMG.Output
+  alias OMG.State.Transaction
+  alias OMG.State.Transaction.Payment
+  alias OMG.Utxo
+
+  require Transaction
+  require Utxo
+
+  @max_inputs 4
+  @max_outputs 4
+  @zero_metadata <<0::256>>
+
+  @payment_tx_type OMG.WireFormatTypes.tx_type_for(:tx_payment_v1)
+  @payment_output_type OMG.WireFormatTypes.output_type_for(:output_payment_v1)
+
+  @payment_v2_tx_type OMG.WireFormatTypes.tx_type_for(:tx_payment_v2)
+  @payment_v2_output_type OMG.WireFormatTypes.output_type_for(:output_payment_v2)
+
+  @output_types %{
+    @payment_tx_type => @payment_output_type,
+    @payment_v2_tx_type => @payment_v2_output_type
+  }
+
+  @doc """
+  Creates a new raw transaction structure from a list of inputs and a list of outputs, given in a succinct tuple form.
+
+  assumptions:
+  ```
+    length(inputs) <= @max_inputs
+    length(outputs) <= @max_outputs
+  ```
+  """
+  @spec new_payment(
+          pos_integer,
+          list({pos_integer, pos_integer, 0..unquote(@max_outputs - 1)}),
+          list({Crypto.address_t(), Payment.currency(), pos_integer}),
+          Transaction.metadata()
+        ) :: Payment.t()
+  def new_payment(tx_type, inputs, outputs, metadata \\ @zero_metadata)
+      when Transaction.is_metadata(metadata) and length(inputs) <= @max_inputs and length(outputs) <= @max_outputs do
+    inputs = Enum.map(inputs, &new_input/1)
+    outputs = Enum.map(outputs, fn output -> new_output(output, @output_types[tx_type]) end)
+    %Transaction.Payment{tx_type: tx_type, inputs: inputs, outputs: outputs, metadata: metadata}
+  end
+
+  # `new_input/1` and `new_output/1` are here to just help interpret the short-hand form of inputs outputs when doing
+  # `new/3`
+  defp new_input({blknum, txindex, oindex}), do: Utxo.position(blknum, txindex, oindex)
+
+  defp new_output({owner, currency, amount}, output_type) do
+    %Output{
+      owner: owner,
+      currency: currency,
+      amount: amount,
+      output_type: output_type
+    }
+  end
+end

apps/omg/lib/omg/wire_format_types.ex

@@ -31,23 +31,20 @@ defmodule OMG.WireFormatTypes do
     3 => OMG.State.Transaction.Fee
   }
 
-  @module_tx_types %{
-    OMG.State.Transaction.Payment => 1,
-    OMG.State.Transaction.Fee => 3
-  }
-
   @input_pointer_type_values %{
     input_pointer_utxo_position: 1
   }
 
   @output_type_values %{
     output_payment_v1: 1,
-    output_fee_token_claim: 2
+    output_fee_token_claim: 2,
+    output_payment_v2: 3
   }
 
   @output_type_modules %{
     1 => OMG.Output,
-    2 => OMG.Output
+    2 => OMG.Output,
+    3 => OMG.Output
   }
 
   @exit_game_tx_types [
@@ -71,12 +68,6 @@ defmodule OMG.WireFormatTypes do
   @spec tx_type_modules() :: tx_type_to_module_map()
   def tx_type_modules(), do: @tx_type_modules
 
-  @doc """
-  Returns the tx type that is associated with the given module
-  """
-  @spec module_tx_types() :: %{atom() => non_neg_integer()}
-  def module_tx_types(), do: @module_tx_types
-
   @doc """
   Returns wire format type value of known input pointer type
   """

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

@@ -92,14 +92,15 @@ defmodule OMG.WatcherInfo.API.Transaction do
       %{advice | transactions: Enum.map(txs, fn tx -> Map.put_new(tx, :typed_data, add_type_specs(tx)) end)}
     }
 
-  defp add_type_specs(%{inputs: inputs, outputs: outputs, metadata: metadata}) do
+  defp add_type_specs(tx) do
     alias OMG.TypedDataHash
 
     message =
       [
-        create_inputs(inputs),
-        create_outputs(outputs),
-        [metadata: metadata || @empty_metadata]
+        create_inputs(tx.inputs),
+        create_outputs(tx.outputs),
+        [metadata: tx.metadata || @empty_metadata],
+        [tx_type: tx.tx_type]
       ]
       |> Enum.concat()
       |> Map.new()

apps/omg_watcher_info/lib/omg_watcher_info/utxo_selection.ex

@@ -22,6 +22,7 @@ defmodule OMG.WatcherInfo.UtxoSelection do
   alias OMG.TypedDataHash
   alias OMG.WatcherInfo.DB
 
+  require Logger
   require Transaction
   require Transaction.Payment
 
@@ -37,6 +38,7 @@ defmodule OMG.WatcherInfo.UtxoSelection do
         }
 
   @type order_t() :: %{
+          tx_type: non_neg_integer(),
           owner: Crypto.address_t(),
           payments: nonempty_list(payment_t()),
           fee: fee_t(),
@@ -71,7 +73,8 @@ defmodule OMG.WatcherInfo.UtxoSelection do
   TODO: seems unocovered by any tests
   """
   @spec create_advice(%{Transaction.Payment.currency() => list(%DB.TxOutput{})}, order_t()) :: advice_t()
-  def create_advice(utxos, %{owner: owner, payments: payments, fee: fee} = order) do
+  def create_advice(utxos, order) do
+    %{tx_type: tx_type, owner: owner, payments: payments, fee: fee} = order
     needed_funds = needed_funds(payments, fee)
     token_utxo_selection = select_utxo(utxos, needed_funds)
 
@@ -83,7 +86,7 @@ defmodule OMG.WatcherInfo.UtxoSelection do
 
       if utxo_count <= Transaction.Payment.max_inputs(),
         do: create_transaction(funds, order) |> respond(:complete),
-        else: create_merge(owner, funds) |> respond(:intermediate)
+        else: create_merge(tx_type, owner, funds) |> respond(:intermediate)
     end
   end
 
@@ -139,7 +142,9 @@ defmodule OMG.WatcherInfo.UtxoSelection do
       else: {:error, {:insufficient_funds, missing_funds}}
   end
 
-  defp create_transaction(utxos_per_token, %{owner: owner, payments: payments, metadata: metadata, fee: fee}) do
+  defp create_transaction(utxos_per_token, order) do
+    %{tx_type: tx_type, owner: owner, payments: payments, metadata: metadata, fee: fee} = order
+
     rests =
       utxos_per_token
       |> Stream.map(fn {token, utxos} ->
@@ -165,10 +170,11 @@ defmodule OMG.WatcherInfo.UtxoSelection do
         {:error, :empty_transaction}
 
       true ->
-        raw_tx = create_raw_transaction(inputs, outputs, metadata)
+        raw_tx = create_raw_transaction(tx_type, inputs, outputs, metadata)
 
         {:ok,
          %{
+           tx_type: tx_type,
            inputs: inputs,
            outputs: outputs,
            fee: fee,
@@ -179,7 +185,7 @@ defmodule OMG.WatcherInfo.UtxoSelection do
     end
   end
 
-  defp create_merge(owner, utxos_per_token) do
+  defp create_merge(tx_type, owner, utxos_per_token) do
     utxos_per_token
     |> Enum.map(fn {token, utxos} ->
       Stream.chunk_every(utxos, Transaction.Payment.max_outputs())
@@ -190,6 +196,7 @@ defmodule OMG.WatcherInfo.UtxoSelection do
 
         inputs ->
           create_transaction([{token, inputs}], %{
+            tx_type: tx_type,
             fee: %{amount: 0, currency: token},
             metadata: @empty_metadata,
             owner: owner,
@@ -201,15 +208,22 @@ defmodule OMG.WatcherInfo.UtxoSelection do
     |> Enum.map(fn {:ok, tx} -> tx end)
   end
 
-  defp create_raw_transaction(inputs, outputs, metadata) do
-    if Enum.any?(outputs, &(&1.owner == nil)),
-      do: nil,
-      else:
-        Transaction.Payment.new(
+  defp create_raw_transaction(tx_type, inputs, outputs, metadata) do
+    # Somehow the API is designed to return nil txbytes instead of claiming that as bad request :(
+    # So we need to return nil here
+    # See the test: "test /transaction.create does not return txbytes when spend owner is not provided"
+    case Enum.any?(outputs, &(&1.owner == nil)) do
+      true ->
+        nil
+
+      false ->
+        Transaction.Payment.Builder.new_payment(
+          tx_type,
           inputs |> Enum.map(&{&1.blknum, &1.txindex, &1.oindex}),
           outputs |> Enum.map(&{&1.owner, &1.currency, &1.amount}),
           metadata || @empty_metadata
         )
+    end
   end
 
   defp create_txbytes(tx) do

apps/omg_watcher_rpc/lib/web/validators/order.ex

@@ -24,6 +24,9 @@ defmodule OMG.WatcherRPC.Web.Validator.Order do
   alias OMG.State.Transaction
   alias OMG.Utils.HttpRPC.Validator.Base
   alias OMG.WatcherInfo.UtxoSelection
+  alias OMG.WireFormatTypes
+
+  @default_tx_type WireFormatTypes.tx_type_for(:tx_payment_v1)
 
   @doc """
   Parses and validates request body
@@ -35,9 +38,14 @@ defmodule OMG.WatcherRPC.Web.Validator.Order do
          {:ok, fee} <- expect(params, "fee", map: &parse_fee/1),
          {:ok, payments} <- expect(params, "payments", list: &parse_payment/1),
          {:ok, payments} <- fills_in_outputs?(payments),
+         {:ok, tx_type} = expect(params, "tx_type", [:integer, :optional]),
          :ok <- ensure_not_self_transaction(owner, payments) do
+      # keep this optional args for backward competibility
+      tx_type = tx_type || @default_tx_type
+
       {:ok,
        %{
+         tx_type: tx_type,
          owner: owner,
          payments: payments,
          fee: fee,

apps/omg_watcher_rpc/lib/web/validators/typed_data_signed.ex

@@ -20,8 +20,12 @@ defmodule OMG.WatcherRPC.Web.Validator.TypedDataSigned do
   alias OMG.State.Transaction
   alias OMG.TypedDataHash.Tools
   alias OMG.Utils.HttpRPC.Validator.Base
+  alias OMG.WireFormatTypes
+
   import OMG.Utils.HttpRPC.Validator.Base
 
+  @default_tx_type WireFormatTypes.tx_type_for(:tx_payment_v1)
+
   @doc """
   Parses and validates request body for /transaction.submit_typed`
   """
@@ -38,10 +42,13 @@ defmodule OMG.WatcherRPC.Web.Validator.TypedDataSigned do
   @spec parse_transaction(map()) :: {:ok, Transaction.Payment.t()} | {:error, any}
   def parse_transaction(params) do
     with {:ok, msg} <- expect(params, "message", :map),
+         {:ok, tx_type} <- expect(msg, "tx_type", [:integer, :optional]),
          inputs when is_list(inputs) <- parse_inputs(msg),
          outputs when is_list(outputs) <- parse_outputs(msg),
          {:ok, metadata} <- expect(msg, "metadata", :hash) do
-      {:ok, Transaction.Payment.new(inputs, outputs, metadata)}
+      # keep this optional args for backward competibility
+      tx_type = tx_type || @default_tx_type
+      {:ok, Transaction.Payment.Builder.new_payment(tx_type, inputs, outputs, metadata)}
     end
   end
 

apps/omg_watcher_rpc/priv/swagger/info_api_specs.yaml

@@ -1772,6 +1772,9 @@ paths:
               title: CreateTransactionsBodySchema
               type: object
               properties:
+                tx_type:
+                  type: integer
+                  format: int256
                 owner:
                   type: string
                 payments:

priv/cabbage/apps/itest/lib/client.ex

@@ -32,6 +32,7 @@ defmodule Itest.Client do
   require Logger
 
   @gas 180_000
+  @payment_v1_tx_type 1
 
   def deposit(amount_in_wei, output_address, vault_address, currency \\ Currency.ether()) do
     deposit_transaction = deposit_transaction(amount_in_wei, output_address, currency)
@@ -52,8 +53,15 @@ defmodule Itest.Client do
     {:ok, receipt_hash}
   end
 
-  def create_transaction(amount_in_wei, input_address, output_address, currency \\ Currency.ether()) do
+  def create_transaction(
+        amount_in_wei,
+        input_address,
+        output_address,
+        currency \\ Currency.ether(),
+        tx_type \\ @payment_v1_tx_type
+      ) do
     transaction = %CreateTransactionsBodySchema{
+      tx_type: tx_type,
       owner: input_address,
       payments: [
         %TransactionCreatePayments{

priv/cabbage/apps/itest/test/features/payment_v2.feature

@@ -0,0 +1,9 @@
+Feature: Payment V2 transaction
+
+  Scenario: Alice sends Bob ETH with payment v1 and v2
+    When Alice deposits "4" ETH to the root chain
+    Then Alice should have "4" ETH on the child chain
+    When Alice sends Bob "1" ETH on the child chain with payment v1
+    Then Bob should have "1" ETH on the child chain
+    When Alice sends Bob "2" ETH on the child chain with payment v2
+    Then Bob should have "3" ETH on the child chain