Fix GeoPatch algorithm

lib/archethic/p2p/geo_patch.ex

@@ -24,73 +24,44 @@ defmodule ArchEthic.P2P.GeoPatch do
   end
 
   defp compute_random_patch do
-    list_char = Enum.concat([?0..?9, ?A..?F])
-    Enum.take_random(list_char, 3) |> List.to_string()
+    list_char1 = Enum.concat([?0..?9, ?A..?F])
+    list_char2 = Enum.concat([?0..?3, ?C..?F])
+
+    Enum.take_random(list_char1, 2)
+    |> List.insert_at(1, Enum.take_random(list_char2, 1))
+    |> List.to_string()
   end
 
   defp compute_patch(lat, lon) do
-    lat_sign = sign(lat)
-    lon_sign = sign(lon)
-
-    fdc = [lat / 90, lon / 180]
-
-    sd =
-      [(lat - lat_sign * 45) / 2, (lon - lon_sign * 90) / 2]
-      |> resolve_with_sign([lat, lon])
+    lon_pos = (lon + 180) / 22.5
+    # Adding 4 to have second digit hex value from C to 3
+    lat_pos = (lat + 90) / 22.5 + 4
 
-    sdc = [List.first(sd) / 22.5, List.last(sd) / 45]
+    first_digit = main_index_patch(trunc(lon_pos))
+    second_digit = main_index_patch(trunc(lat_pos))
 
-    td =
-      [
-        (List.first(sd) - lat_sign * 11.25) / 2,
-        (List.last(sd) - lon_sign * 22.5) / 2
-      ]
-      |> resolve_with_sign(sd)
+    lat_precision = ((lat_pos - trunc(lat_pos)) / 0.25) |> trunc()
+    lon_precision = ((lon_pos - trunc(lon_pos)) / 0.25) |> trunc()
 
-    tdc = [List.first(td) / 5.625, List.last(td) / 11.25]
+    third_digit = precision_index_patch(lat_precision, lon_precision)
 
-    patch =
-      [index_patch(fdc), index_patch(sdc), index_patch(tdc)]
-      |> Enum.join("")
-
-    patch
+    [first_digit, second_digit, third_digit]
+    |> Enum.join("")
   end
 
-  defp index_patch([f_i, s_i]) when f_i > 0.5 and f_i <= 1 and s_i < -0.5 and s_i >= -1, do: '0'
-  defp index_patch([f_i, s_i]) when f_i > 0.5 and f_i <= 1 and s_i < 0 and s_i >= -0.5, do: '1'
-  defp index_patch([f_i, s_i]) when f_i > 0.5 and f_i <= 1 and s_i < 0.5 and s_i >= 0, do: '2'
-  defp index_patch([f_i, s_i]) when f_i > 0.5 and f_i <= 1 and s_i < 1 and s_i >= 0.5, do: '3'
-
-  defp index_patch([f_i, s_i]) when f_i > 0 and f_i <= 0.5 and s_i < -0.5 and s_i >= -1, do: '4'
-  defp index_patch([f_i, s_i]) when f_i > 0 and f_i <= 0.5 and s_i < 0 and s_i >= -0.5, do: '5'
-  defp index_patch([f_i, s_i]) when f_i > 0 and f_i <= 0.5 and s_i < 0.5 and s_i >= 0, do: '6'
-  defp index_patch([f_i, s_i]) when f_i > 0 and f_i <= 0.5 and s_i < 1 and s_i >= 0.5, do: '7'
-
-  defp index_patch([f_i, s_i]) when f_i > -0.5 and f_i <= 0 and s_i < -0.5 and s_i >= -1, do: '8'
-  defp index_patch([f_i, s_i]) when f_i > -0.5 and f_i <= 0 and s_i < 0 and s_i >= -0.5, do: '9'
-  defp index_patch([f_i, s_i]) when f_i > -0.5 and f_i <= 0 and s_i < 0.5 and s_i >= 0, do: 'A'
-  defp index_patch([f_i, s_i]) when f_i > -0.5 and f_i <= 0 and s_i < 1 and s_i >= 0.5, do: 'B'
-
-  defp index_patch([f_i, s_i]) when f_i > -1 and f_i <= -0.5 and s_i < -0.5 and s_i >= -1, do: 'C'
-  defp index_patch([f_i, s_i]) when f_i > -1 and f_i <= -0.5 and s_i < 0 and s_i >= -0.5, do: 'D'
-  defp index_patch([f_i, s_i]) when f_i > -1 and f_i <= -0.5 and s_i < 0.5 and s_i >= 0, do: 'E'
-  defp index_patch([f_i, s_i]) when f_i > -1 and f_i <= -0.5 and s_i < 1 and s_i >= 0.5, do: 'F'
-
-  defp sign(number) when number < 0, do: -1
-  defp sign(number) when number >= 0, do: 1
+  defp main_index_patch(index) do
+    ['8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7']
+    |> Enum.at(index)
+  end
 
-  defp resolve_with_sign([first, second], [first2, second2]) do
+  defp precision_index_patch(index1, index2) do
     [
-      do_resolve_with_sign(first, first2),
-      do_resolve_with_sign(second, second2)
+      ['0', '1', '2', '3'],
+      ['4', '5', '6', '7'],
+      ['8', '9', 'A', 'B'],
+      ['C', 'D', 'E', 'F']
     ]
-  end
-
-  defp do_resolve_with_sign(x1, x2) do
-    if sign(x1) == sign(x2) do
-      x1
-    else
-      x2 / 2
-    end
+    |> Enum.at(index1)
+    |> Enum.at(index2)
   end
 end

test/archethic/bootstrap_test.exs

@@ -305,6 +305,9 @@ defmodule ArchEthic.BootstrapTest do
       MockDB
       |> stub(:get_first_public_key, fn _ -> first_public_key end)
 
+      MockGeoIP
+      |> stub(:get_coordinates, fn {200, 50, 20, 10} -> {0.0, 0.0} end)
+
       assert :ok =
                Bootstrap.run(
                  {200, 50, 20, 10},

test/archethic/p2p/geo_patch_test.exs

@@ -1,12 +1,17 @@
 defmodule ArchEthic.P2P.GeoPatchTest do
+  @moduledoc """
+  This module defines the test case to be used by
+  geopatch tests.
+  """
+
   use ExUnit.Case
 
   alias ArchEthic.P2P.GeoPatch
 
   import Mox
 
   test "from_ip/1 should compute patch from coordinates" do
-    expect(MockGeoIP, :get_coordinates, fn ip ->
+    stub(MockGeoIP, :get_coordinates, fn ip ->
       case ip do
         # Spain (Alicante)
         {88, 22, 30, 229} ->
@@ -23,12 +28,17 @@ defmodule ArchEthic.P2P.GeoPatchTest do
         # Switzerland (Zurich)
         {109, 164, 214, 168} ->
           {47.366670, 8.550000}
+
+        # Edge value
+        {1, 2, 3, 4} ->
+          {-45.0, 0.0}
       end
     end)
 
-    assert "511" == GeoPatch.from_ip({88, 22, 30, 229})
-    assert "500" == GeoPatch.from_ip({161, 235, 112, 33})
-    assert "410" == GeoPatch.from_ip({15, 62, 246, 57})
-    assert "266" == GeoPatch.from_ip({109, 164, 214, 168})
+    assert "F1B" == GeoPatch.from_ip({88, 22, 30, 229})
+    assert "C1D" == GeoPatch.from_ip({161, 235, 112, 33})
+    assert "A1A" == GeoPatch.from_ip({15, 62, 246, 57})
+    assert "021" == GeoPatch.from_ip({109, 164, 214, 168})
+    assert "0E0" == GeoPatch.from_ip({1, 2, 3, 4})
   end
 end

test/test_helper.exs

@@ -17,3 +17,5 @@ Mox.defmock(MockGeoIP, for: ArchEthic.P2P.GeoPatch.GeoIP)
 Mox.defmock(MockUCOPriceProvider, for: ArchEthic.OracleChain.Services.UCOPrice.Providers.Impl)
 
 Mox.defmock(MockMetricsCollector, for: ArchEthic.Metrics.Collector)
+
+Application.put_env(:archethic, ArchEthic.P2P.GeoPatch.GeoIP, MockGeoIP)