Change EXIT_PROCESSOR_SLA_MARGIN to EXIT_PROCESSOR_SLA_SECONDS

apps/omg_status/test/omg_status/monitor/memory_monitor_test.exs

@@ -58,7 +58,7 @@ defmodule OMG.Status.Monitor.MemoryMonitorTest do
     assert_receive :got_clear_alarm
   end
 
-  test "works with :buffered_memory and :cached_memory values are not provided", context do
+  test "works with :buffered_memory and :cached_memory values are not provided" do
     set_memsup(total_memory: 1000, free_memory: 100)
     assert_receive :got_raise_alarm
   end

apps/omg_watcher/lib/omg_watcher/api/configuration.ex

@@ -22,7 +22,7 @@ defmodule OMG.Watcher.API.Configuration do
   @spec get_configuration() :: {:ok, map()}
   def get_configuration() do
     configuration = %{
-      exit_processor_sla_margin: Configuration.exit_processor_sla_margin(),
+      exit_processor_sla_seconds: Configuration.exit_processor_sla_seconds(),
       deposit_finality_margin: OMG.Configuration.deposit_finality_margin(),
       contract_semver: OMG.Eth.Configuration.contract_semver(),
       network: OMG.Eth.Configuration.network()

apps/omg_watcher/lib/omg_watcher/configuration.ex

@@ -17,8 +17,8 @@ defmodule OMG.Watcher.Configuration do
   Provides access to applications configuration
   """
   @app :omg_watcher
-  def exit_processor_sla_margin() do
-    Application.fetch_env!(@app, :exit_processor_sla_margin)
+  def exit_processor_sla_seconds() do
+    Application.fetch_env!(@app, :exit_processor_sla_seconds)
   end
 
   def exit_processor_sla_margin_forced() do

apps/omg_watcher/lib/omg_watcher/exit_processor.ex

@@ -247,34 +247,31 @@ defmodule OMG.Watcher.ExitProcessor do
   Reads the exit data from `OMG.DB`.
 
   Options:
-    - `exit_processor_sla_margin`: number of blocks after exit start before it's considered late (and potentially:
+    - `exit_processor_sla_seconds`: seconds after exit start before it's considered late (and potentially:
       unchallenged)
-    - `exit_processor_sla_margin_forced`: if `true` will override the check of `exit_processor_sla_margin` against
+    - `exit_processor_sla_margin_forced`: if `true` will override the check of `exit_processor_sla_seconds` against
       `min_exit_period_seconds`
     - `min_exit_period_seconds`: should reflect the value of this parameter for the specific child chain watched,
-    - `ethereum_block_time_seconds`: just to relate blocks to seconds for the `exit_processor_sla_margin` check
     - `metrics_collection_interval`: how often are the metrics sent to `telemetry` (in milliseconds)
   """
   def init(
-        exit_processor_sla_margin: exit_processor_sla_margin,
+        exit_processor_sla_seconds: exit_processor_sla_seconds,
         exit_processor_sla_margin_forced: exit_processor_sla_margin_forced,
         metrics_collection_interval: metrics_collection_interval,
-        min_exit_period_seconds: min_exit_period_seconds,
-        ethereum_block_time_seconds: ethereum_block_time_seconds
+        min_exit_period_seconds: min_exit_period_seconds
       ) do
     {:ok, db_exits} = DB.exit_infos()
     {:ok, db_ifes} = DB.in_flight_exits_info()
     {:ok, db_competitors} = DB.competitors_info()
 
     :ok =
-      Core.check_sla_margin(
-        exit_processor_sla_margin,
+      Core.check_sla_seconds(
+        exit_processor_sla_seconds,
         exit_processor_sla_margin_forced,
-        min_exit_period_seconds,
-        ethereum_block_time_seconds
+        min_exit_period_seconds
       )
 
-    {:ok, processor} = Core.init(db_exits, db_ifes, db_competitors, exit_processor_sla_margin)
+    {:ok, processor} = Core.init(db_exits, db_ifes, db_competitors, exit_processor_sla_seconds)
     {:ok, _} = :timer.send_interval(metrics_collection_interval, self(), :send_metrics)
 
     _ = Logger.info("Initializing with: #{inspect(processor)}")

apps/omg_watcher/lib/omg_watcher/exit_processor/core.ex

@@ -44,7 +44,7 @@ defmodule OMG.Watcher.ExitProcessor.Core do
 
   use OMG.Utils.LoggerExt
 
-  @default_sla_margin 10
+  @default_sla_seconds 10
   @zero_address OMG.Eth.zero_address()
 
   @max_inputs Transaction.Payment.max_inputs()
@@ -68,10 +68,10 @@ defmodule OMG.Watcher.ExitProcessor.Core do
 
   @type new_piggyback_event_t() :: new_piggyback_input_event_t() | new_piggyback_output_event_t()
 
-  defstruct [:sla_margin, exits: %{}, in_flight_exits: %{}, exit_ids: %{}, competitors: %{}]
+  defstruct [:sla_seconds, exits: %{}, in_flight_exits: %{}, exit_ids: %{}, competitors: %{}]
 
   @type t :: %__MODULE__{
-          sla_margin: non_neg_integer(),
+          sla_seconds: non_neg_integer(),
           exits: %{Utxo.Position.t() => ExitInfo.t()},
           in_flight_exits: %{Transaction.tx_hash() => InFlightExitInfo.t()},
           # NOTE: maps only standard exit_ids to the natural keys of standard exits (input pointers/utxo_pos)
@@ -101,9 +101,9 @@ defmodule OMG.Watcher.ExitProcessor.Core do
           db_exits :: [{{pos_integer, non_neg_integer, non_neg_integer}, map}],
           db_in_flight_exits :: [{Transaction.tx_hash(), InFlightExitInfo.t()}],
           db_competitors :: [{Transaction.tx_hash(), CompetitorInfo.t()}],
-          sla_margin :: non_neg_integer
+          sla_seconds :: non_neg_integer
         ) :: {:ok, t()}
-  def init(db_exits, db_in_flight_exits, db_competitors, sla_margin \\ @default_sla_margin) do
+  def init(db_exits, db_in_flight_exits, db_competitors, sla_seconds \\ @default_sla_seconds) do
     exits = db_exits |> Enum.map(&ExitInfo.from_db_kv/1) |> Map.new()
     exit_ids = exits |> Enum.into(%{}, fn {utxo_pos, %ExitInfo{exit_id: exit_id}} -> {exit_id, utxo_pos} end)
 
@@ -113,30 +113,30 @@ defmodule OMG.Watcher.ExitProcessor.Core do
        in_flight_exits: db_in_flight_exits |> Enum.map(&InFlightExitInfo.from_db_kv/1) |> Map.new(),
        exit_ids: exit_ids,
        competitors: db_competitors |> Enum.map(&CompetitorInfo.from_db_kv/1) |> Map.new(),
-       sla_margin: sla_margin
+       sla_seconds: sla_seconds
      }}
   end
 
   @doc """
-  Use to check if the settings regarding the `:exit_processor_sla_margin` config of `:omg_watcher` are OK.
+  Use to check if the settings regarding the `:exit_processor_sla_seconds` config of `:omg_watcher` are OK.
 
   Since there are combinations of our configuration that may lead to a dangerous setup of the Watcher
-  (in particular - muting the reports of unchallenged_exits), we're enforcing that the `exit_processor_sla_margin`
+  (in particular - muting the reports of unchallenged_exits), we're enforcing that the `exit_processor_sla_seconds`
   be not larger than `min_exit_period`.
   """
-  @spec check_sla_margin(pos_integer(), boolean(), pos_integer(), pos_integer()) :: :ok | {:error, :sla_margin_too_big}
-  def check_sla_margin(sla_margin, sla_margin_forced, min_exit_period_seconds, ethereum_block_time_seconds)
+  @spec check_sla_seconds(pos_integer(), boolean(), pos_integer()) :: :ok | {:error, :sla_margin_too_big}
+  def check_sla_seconds(sla_seconds, sla_margin_forced, min_exit_period_seconds)
 
-  def check_sla_margin(sla_margin, true, min_exit_period_seconds, ethereum_block_time_seconds) do
+  def check_sla_seconds(sla_seconds, true, min_exit_period_seconds) do
     _ =
-      if !sla_margin_safe?(sla_margin, min_exit_period_seconds, ethereum_block_time_seconds),
-        do: Logger.warn("Allowing unsafe sla margin of #{sla_margin} blocks")
+      if !sla_seconds_safe?(sla_seconds, min_exit_period_seconds),
+        do: Logger.warn("Allowing unsafe sla margin of #{sla_seconds} seconds")
 
     :ok
   end
 
-  def check_sla_margin(sla_margin, false, min_exit_period_seconds, ethereum_block_time_seconds) do
-    if sla_margin_safe?(sla_margin, min_exit_period_seconds, ethereum_block_time_seconds),
+  def check_sla_seconds(sla_seconds, false, min_exit_period_seconds) do
+    if sla_seconds_safe?(sla_seconds, min_exit_period_seconds),
       do: :ok,
       else: {:error, :sla_margin_too_big}
   end
@@ -587,6 +587,6 @@ defmodule OMG.Watcher.ExitProcessor.Core do
     address != @zero_address
   end
 
-  defp sla_margin_safe?(exit_processor_sla_margin, min_exit_period_seconds, ethereum_block_time_seconds),
-    do: exit_processor_sla_margin * ethereum_block_time_seconds < min_exit_period_seconds
+  defp sla_seconds_safe?(exit_processor_sla_seconds, min_exit_period_seconds),
+    do: exit_processor_sla_seconds < min_exit_period_seconds
 end

apps/omg_watcher/lib/omg_watcher/exit_processor/standard_exit.ex

@@ -67,7 +67,7 @@ defmodule OMG.Watcher.ExitProcessor.StandardExit do
   """
   @spec get_invalid(Core.t(), %{Utxo.Position.t() => boolean}, pos_integer()) ::
           {%{Utxo.Position.t() => ExitInfo.t()}, %{Utxo.Position.t() => ExitInfo.t()}}
-  def get_invalid(%Core{sla_margin: sla_margin} = state, utxo_exists?, eth_height_now) do
+  def get_invalid(%Core{sla_seconds: sla_seconds} = state, utxo_exists?, eth_height_now) do
     active_exits = active_exits(state)
 
     invalid_exit_positions =
@@ -79,10 +79,13 @@ defmodule OMG.Watcher.ExitProcessor.StandardExit do
     exits_invalid_by_ife = get_invalid_exits_based_on_ifes(active_exits, tx_appendix)
     invalid_exits = active_exits |> Map.take(invalid_exit_positions) |> Enum.concat(exits_invalid_by_ife) |> Enum.uniq()
 
+    _ethereum_block_time_seconds = OMG.Eth.Configuration.ethereum_block_time_seconds()
     # get exits which are still invalid and after the SLA margin
+    # temporarily assigning ethereum_block_time_seconds= 1, will be removed on merge of #1495
     late_invalid_exits =
-      invalid_exits
-      |> Enum.filter(fn {_, %ExitInfo{eth_height: eth_height}} -> eth_height + sla_margin <= eth_height_now end)
+      Enum.filter(invalid_exits, fn {_, %ExitInfo{eth_height: eth_height}} ->
+        eth_height + sla_seconds / 1 <= eth_height_now
+      end)
 
     {Map.new(invalid_exits), Map.new(late_invalid_exits)}
   end

apps/omg_watcher/lib/omg_watcher/release_tasks/set_exit_processor_sla_margin.ex

@@ -18,8 +18,8 @@ defmodule OMG.Watcher.ReleaseTasks.SetExitProcessorSLAMargin do
   require Logger
   @app :omg_watcher
 
-  @system_env_name_margin "EXIT_PROCESSOR_SLA_MARGIN"
-  @app_env_name_margin :exit_processor_sla_margin
+  @system_env_name "EXIT_PROCESSOR_SLA_SECONDS"
+  @app_env_name :exit_processor_sla_seconds
 
   @system_env_name_force "EXIT_PROCESSOR_SLA_MARGIN_FORCED"
   @app_env_name_force :exit_processor_sla_margin_forced
@@ -33,15 +33,15 @@ defmodule OMG.Watcher.ReleaseTasks.SetExitProcessorSLAMargin do
 
     Config.Reader.merge(config,
       omg_watcher: [
-        exit_processor_sla_margin: get_exit_processor_sla_margin(),
+        exit_processor_sla_seconds: get_exit_processor_sla_seconds(),
         exit_processor_sla_margin_forced: get_exit_processor_sla_forced()
       ]
     )
   end
 
-  defp get_exit_processor_sla_margin() do
-    config_value = validate_int(get_env(@system_env_name_margin), Application.get_env(@app, @app_env_name_margin))
-    _ = Logger.info("CONFIGURATION: App: #{@app} Key: #{@system_env_name_margin} Value: #{inspect(config_value)}.")
+  defp get_exit_processor_sla_seconds() do
+    config_value = validate_int(get_env(@system_env_name), Application.get_env(@app, @app_env_name))
+    _ = Logger.info("CONFIGURATION: App: #{@app} Key: #{@system_env_name} Value: #{inspect(config_value)}.")
     config_value
   end
 
@@ -66,7 +66,7 @@ defmodule OMG.Watcher.ReleaseTasks.SetExitProcessorSLAMargin do
   defp to_int(value) do
     case Integer.parse(value) do
       {result, ""} -> result
-      _ -> exit("#{@system_env_name_margin} must be an integer.")
+      _ -> exit("#{@system_env_name} must be an integer.")
     end
   end
 end

apps/omg_watcher/lib/omg_watcher/sync_supervisor.ex

@@ -45,25 +45,23 @@ defmodule OMG.Watcher.SyncSupervisor do
 
   defp children(args) do
     contract_deployment_height = Keyword.fetch!(args, :contract_deployment_height)
-    exit_processor_sla_margin = Configuration.exit_processor_sla_margin()
+    exit_processor_sla_seconds = Configuration.exit_processor_sla_seconds()
     exit_processor_sla_margin_forced = Configuration.exit_processor_sla_margin_forced()
     metrics_collection_interval = Configuration.metrics_collection_interval()
     finality_margin = Configuration.exit_finality_margin()
     deposit_finality_margin = OMG.Configuration.deposit_finality_margin()
     ethereum_events_check_interval_ms = OMG.Configuration.ethereum_events_check_interval_ms()
     coordinator_eth_height_check_interval_ms = OMG.Configuration.coordinator_eth_height_check_interval_ms()
     min_exit_period_seconds = OMG.Eth.Configuration.min_exit_period_seconds()
-    ethereum_block_time_seconds = OMG.Eth.Configuration.ethereum_block_time_seconds()
     contracts = OMG.Eth.Configuration.contracts()
 
     [
       {ExitProcessor,
        [
-         exit_processor_sla_margin: exit_processor_sla_margin,
+         exit_processor_sla_seconds: exit_processor_sla_seconds,
          exit_processor_sla_margin_forced: exit_processor_sla_margin_forced,
          metrics_collection_interval: metrics_collection_interval,
-         min_exit_period_seconds: min_exit_period_seconds,
-         ethereum_block_time_seconds: ethereum_block_time_seconds
+         min_exit_period_seconds: min_exit_period_seconds
        ]},
       %{
         id: OMG.Watcher.BlockGetter.Supervisor,

apps/omg_watcher/test/omg_watcher/exit_processor/core_test.exs

@@ -116,15 +116,15 @@ defmodule OMG.Watcher.ExitProcessor.CoreTest do
     end
   end
 
-  describe "check_sla_margin/4" do
+  describe "check_sla_margin/3" do
     test "allows only safe margins if not forcing" do
-      assert {:error, :sla_margin_too_big} = Core.check_sla_margin(10, false, 100, 15)
-      assert :ok = Core.check_sla_margin(10, false, 300, 15)
+      assert {:error, :sla_margin_too_big} = Core.check_sla_seconds(150, false, 100)
+      assert :ok = Core.check_sla_seconds(150, false, 300)
     end
 
     test "allows anything if forcing" do
-      capture_log(fn -> assert :ok = Core.check_sla_margin(10, true, 100, 15) end)
-      assert :ok = Core.check_sla_margin(10, true, 300, 15)
+      capture_log(fn -> assert :ok = Core.check_sla_seconds(150, true, 100) end)
+      assert :ok = Core.check_sla_seconds(150, true, 300)
     end
   end
 

apps/omg_watcher/test/omg_watcher/integration/block_getter_test.exs

@@ -183,7 +183,7 @@ defmodule OMG.Watcher.Integration.BlockGetterTest do
   end
 
   @tag fixtures: [:in_beam_watcher, :stable_alice, :mix_based_child_chain, :token, :stable_alice_deposits, :test_server]
-  test "transaction which is spending an exiting output before the `sla_margin` causes an invalid_exit event only",
+  test "transaction which is spending an exiting output before the `sla_seconds` causes an invalid_exit event only",
        %{stable_alice: alice, stable_alice_deposits: {deposit_blknum, _}, test_server: context} do
     tx = OMG.TestHelper.create_encoded([{deposit_blknum, 0, 0, alice}], @eth, [{alice, 9}])
     %{"blknum" => exit_blknum} = WatcherHelper.submit(tx)
@@ -223,14 +223,14 @@ defmodule OMG.Watcher.Integration.BlockGetterTest do
 
     # Here we're manually submitting invalid block to the root chain
     # NOTE: this **must** come after `start_exit` is mined (see just above) but still not later than
-    #       `sla_margin` after exit start, hence the `config/test.exs` entry for the margin is rather high
+    #       `sla_seconds` after exit start, hence the `config/test.exs` entry for the margin is rather high
     {:ok, _} = Eth.submit_block(bad_block_hash, 2, 1)
 
     IntegrationTest.wait_for_byzantine_events([%Event.InvalidExit{}.name], @timeout)
   end
 
   @tag fixtures: [:in_beam_watcher, :stable_alice, :mix_based_child_chain, :token, :stable_alice_deposits, :test_server]
-  test "transaction which is spending an exiting output after the `sla_margin` causes an unchallenged_exit event",
+  test "transaction which is spending an exiting output after the `sla_seconds` causes an unchallenged_exit event",
        %{stable_alice: alice, stable_alice_deposits: {deposit_blknum, _}, test_server: context} do
     tx = OMG.TestHelper.create_encoded([{deposit_blknum, 0, 0, alice}], @eth, [{alice, 9}])
     %{"blknum" => exit_blknum} = WatcherHelper.submit(tx)
@@ -259,7 +259,7 @@ defmodule OMG.Watcher.Integration.BlockGetterTest do
       "utxo_pos" => utxo_pos
     } = WatcherHelper.get_exit_data(exit_blknum, 0, 0)
 
-    {:ok, %{"status" => "0x1", "blockNumber" => eth_height}} =
+    {:ok, %{"status" => "0x1"}} =
       RootChainHelper.start_exit(
         utxo_pos,
         txbytes,
@@ -268,8 +268,9 @@ defmodule OMG.Watcher.Integration.BlockGetterTest do
       )
       |> DevHelper.transact_sync!()
 
-    exit_processor_sla_margin = Application.fetch_env!(:omg_watcher, :exit_processor_sla_margin)
-    DevHelper.wait_for_root_chain_block(eth_height + exit_processor_sla_margin, @timeout)
+    exit_processor_sla_seconds = Application.fetch_env!(:omg_watcher, :exit_processor_sla_seconds)
+    exit_processor_sla_ms = exit_processor_sla_seconds * 1000
+    Process.sleep(exit_processor_sla_ms)
 
     # checking if both machines and humans learn about the byzantine condition
     assert WatcherHelper.capture_log(fn ->

apps/omg_watcher/test/omg_watcher/integration/invalid_exit_test.exs

@@ -96,7 +96,7 @@ defmodule OMG.Watcher.Integration.InvalidExitTest do
   end
 
   @tag fixtures: [:in_beam_watcher, :stable_alice, :mix_based_child_chain, :token, :stable_alice_deposits]
-  test "invalid_exit without a challenge raises unchallenged_exit after sla_margin had passed, can be challenged",
+  test "invalid_exit without a challenge raises unchallenged_exit after sla_seconds had passed, can be challenged",
        %{stable_alice: alice, stable_alice_deposits: {deposit_blknum, _}} do
     %{"blknum" => first_tx_blknum} =
       OMG.TestHelper.create_encoded([{deposit_blknum, 0, 0, alice}], @eth, [{alice, 9}]) |> WatcherHelper.submit()
@@ -109,14 +109,16 @@ defmodule OMG.Watcher.Integration.InvalidExitTest do
     %{"txbytes" => txbytes, "proof" => proof, "utxo_pos" => tx_utxo_pos} =
       WatcherHelper.get_exit_data(first_tx_blknum, 0, 0)
 
-    {:ok, %{"status" => "0x1", "blockNumber" => eth_height}} =
+    {:ok, %{"status" => "0x1"}} =
       RootChainHelper.start_exit(tx_utxo_pos, txbytes, proof, alice.addr)
       |> DevHelper.transact_sync!()
 
     IntegrationTest.wait_for_byzantine_events([%Event.InvalidExit{}.name], @timeout)
 
-    exit_processor_sla_margin = Application.fetch_env!(:omg_watcher, :exit_processor_sla_margin)
-    DevHelper.wait_for_root_chain_block(eth_height + exit_processor_sla_margin, @timeout)
+    exit_processor_sla_seconds = Application.fetch_env!(:omg_watcher, :exit_processor_sla_seconds)
+    exit_processor_sla_ms = exit_processor_sla_seconds * 1000
+    # after exit, the event fetch time + waiting for sla_margin goes beyond the required time
+    Process.sleep(exit_processor_sla_ms)
     IntegrationTest.wait_for_byzantine_events([%Event.InvalidExit{}.name, %Event.UnchallengedExit{}.name], @timeout)
 
     # after the notification has been received, a challenged is composed and sent, regardless of it being late